Projects
Mega:24.03
gcc
Sign Up
Log In
Username
Password
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
Expand all
Collapse all
Changes of Revision 2
View file
_service:tar_scm:gcc.spec
Changed
@@ -2,7 +2,7 @@ %global gcc_major 12 # Note, gcc_release must be integer, if you want to add suffixes to # %%{release}, append them after %%{gcc_release} on Release: line. -%global gcc_release 17 +%global gcc_release 19 %global _unpackaged_files_terminate_build 0 %global _performance_build 1 @@ -23,38 +23,38 @@ %else %global build_libquadmath 0 %endif -%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 +%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 loongarch64 %global build_libasan 1 %else %global build_libasan 0 %endif -%ifarch x86_64 ppc64 ppc64le aarch64 s390x +%ifarch x86_64 ppc64 ppc64le aarch64 s390x loongarch64 %global build_libtsan 1 %else %global build_libtsan 0 %endif -%ifarch x86_64 ppc64 ppc64le aarch64 s390x +%ifarch x86_64 ppc64 ppc64le aarch64 s390x loongarch64 %global build_liblsan 1 %else %global build_liblsan 0 %endif -%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 +%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 loongarch64 %global build_libubsan 1 %else %global build_libubsan 0 %endif -%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 %{mips} riscv64 +%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 %{mips} riscv64 loongarch64 %global build_libatomic 1 %else %global build_libatomic 0 %endif -%ifarch %{ix86} x86_64 %{arm} alpha ppc ppc64 ppc64le ppc64p7 s390 s390x aarch64 +%ifarch %{ix86} x86_64 %{arm} alpha ppc ppc64 ppc64le ppc64p7 s390 s390x aarch64 loongarch64 %global build_libitm 1 %else %global build_libitm 0 %endif %global build_libstdcxx_docs 0 -%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 %{mips} +%ifarch %{ix86} x86_64 ppc ppc64 ppc64le ppc64p7 s390 s390x %{arm} aarch64 %{mips} loongarch64 %global attr_ifunc 1 %else %global attr_ifunc 0 @@ -72,6 +72,9 @@ %global _lib lib %global _smp_mflags -j8 %endif +%ifarch loongarch64 +%global _lib lib +%endif %global isl_enable 1 %global check_enable 0 @@ -164,6 +167,135 @@ Patch27: 0027-LoopElim-Redundant-loop-elimination-optimization.patch Patch28: 0028-Array-widen-compare-Fix-the-return-value-match-after.patch +# Part 3000 ~ 4999 +%ifarch loongarch64 +Patch3001: loongarch-add-alternatives-for-idiv-insns-to-improve.patch +Patch3002: loongarch-avoid-unnecessary-sign-extend-after-32-bit.patch +Patch3003: LoongArch-Subdivision-symbol-type-add-SYMBOL_PCREL-s.patch +Patch3004: LoongArch-Support-split-symbol.patch +Patch3005: LoongArch-Modify-the-output-message-string-of-the-wa.patch +Patch3006: LoongArch-adjust-the-default-of-mexplicit-relocs-by-.patch +Patch3007: LoongArch-document-m-no-explicit-relocs.patch +Patch3008: LoongArch-Define-the-macro-ASM_PREFERRED_EH_DATA_FOR.patch +Patch3009: LoongArch-Provide-fmin-fmax-RTL-pattern.patch +Patch3010: LoongArch-Get-__tls_get_addr-address-through-got-tab.patch +Patch3011: LoongArch-Add-support-code-model-extreme.patch +Patch3012: LoongArch-Add-new-code-model-medium.patch +Patch3013: LoongArch-Avoid-RTL-flag-check-failure-in-loongarch_.patch +Patch3014: LoongArch-add-model-attribute.patch +Patch3015: LoongArch-testsuite-refine-__tls_get_addr-tests-with.patch +Patch3016: LoongArch-add-mdirect-extern-access-option.patch +Patch3017: LoongArch-Fix-pr106828-by-define-hook-TARGET_ASAN_SH.patch +Patch3018: LoongArch-Prepare-static-PIE-support.patch +Patch3019: LoongArch-Libitm-add-LoongArch-support.patch +Patch3020: LoongArch-Fixed-a-typo-in-the-comment-information-of.patch +Patch3021: LoongArch-Use-UNSPEC-for-fmin-fmax-RTL-pattern-PR105.patch +Patch3022: LoongArch-Fixed-a-bug-in-the-loongarch-architecture-.patch +Patch3023: LoongArch-implement-count_-leading-trailing-_zeros.patch +Patch3024: Libvtv-Add-loongarch-support.patch +Patch3025: LoongArch-Add-fcopysign-instructions.patch +Patch3026: LoongArch-fix-signed-overflow-in-loongarch_emit_int_.patch +Patch3027: LoongArch-Rename-frint_-fmt-to-rint-mode-2.patch +Patch3028: LoongArch-Add-ftint-rm-rp-.-w-l-.-s-d-instructions.patch +Patch3029: LoongArch-Add-fscaleb.-s-d-instructions-as-ldexp-sf-.patch +Patch3030: LoongArch-Add-flogb.-s-d-instructions-and-expand-log.patch +Patch3031: LoongArch-Add-prefetch-instructions.patch +Patch3032: LoongArch-Optimize-immediate-load.patch +Patch3033: LoongArch-Optimize-the-implementation-of-stack-check.patch +Patch3034: LoongArch-Fixed-a-compilation-failure-with-c-in-inli.patch +Patch3035: LoongArch-Don-t-add-crtfastmath.o-for-shared.patch +Patch3036: LoongArch-Generate-bytepick.-wd-for-suitable-bit-ope.patch +Patch3037: LoongArch-Change-the-value-of-macro-TRY_EMPTY_VM_SPA.patch +Patch3038: LoongArch-testsuite-Disable-stack-protector-for-some.patch +Patch3039: LoongArch-Add-built-in-functions-description-of-Loon.patch +Patch3040: LoongArch-Remove-the-definition-of-the-macro-LOGICAL.patch +Patch3041: LoongArch-Optimize-additions-with-immediates.patch +Patch3042: LoongArch-Improve-GAR-store-for-va_list.patch +Patch3043: LoongArch-Improve-cpymemsi-expansion-PR109465.patch +Patch3044: LoongArch-Fix-MUSL_DYNAMIC_LINKER.patch +Patch3045: LoongArch-Enable-shrink-wrapping.patch +Patch3046: LoongArch-Change-the-default-value-of-LARCH_CALL_RAT.patch +Patch3047: LoongArch-Set-default-alignment-for-functions-and-la.patch +Patch3048: LoongArch-Avoid-non-returning-indirect-jumps-through.patch +Patch3049: Loongarch-Fix-plugin-header-missing-install.patch +Patch3050: libffi-Backport-of-LoongArch-support-for-libffi.patch +Patch3051: LoongArch-Remove-redundant-sign-extension-instructio.patch +Patch3052: LoongArch-Enable-free-starting-at-O2.patch +Patch3053: LoongArch-Fix-bug-in-loongarch_emit_stack_tie-PR1104.patch +Patch3054: LoongArch-Implement-128-bit-floating-point-functions.patch +Patch3056: LoongArch-Optimize-switch-with-sign-extended-index.patch +Patch3057: LoongArch-Support-storing-floating-point-zero-into-M.patch +Patch3058: LoongArch-improved-target-configuration-interface.patch +Patch3059: LoongArch-define-preprocessing-macros-__loongarch_-a.patch +Patch3060: LoongArch-add-new-configure-option-with-strict-align.patch +Patch3061: LoongArch-support-loongarch-elf-target.patch +Patch3062: LoongArch-initial-ada-support-on-linux.patch +Patch3063: LoongArch-Add-Loongson-SX-base-instruction-support.patch +Patch3064: LoongArch-Add-Loongson-SX-directive-builtin-function.patch +Patch3065: LoongArch-Add-Loongson-ASX-base-instruction-support.patch +Patch3066: LoongArch-Add-Loongson-ASX-directive-builtin-functio.patch +Patch3067: LoongArch-Fix-unintentionally-breakage-in-r14-3665.patch +Patch3068: LoongArch-Use-bstrins-instruction-for-a-mask-and-a-m.patch +Patch3069: LoongArch-Adjust-C-multilib-header-layout.patch +Patch3070: LoongArch-Fix-unintentional-bash-ism-in-r14-3665.patch +Patch3071: LoongArch-Enable-fsched-pressure-by-default-at-O1-an.patch +Patch3072: LoongArch-Use-LSX-and-LASX-for-block-move.patch +Patch3073: LoongArch-Slightly-simplify-loongarch_block_move_str.patch +Patch3074: LoongArch-Optimized-multiply-instruction-generation.patch +Patch3075: LoongArch-Fix-up-memcpy-vec-3.c-test-case.patch +Patch3076: LoongArch-Add-tests-of-mstrict-align-option.patch +Patch3077: LoongArch-Add-testsuite-framework-for-Loongson-SX-AS.patch +Patch3078: LoongArch-Add-tests-for-Loongson-SX-builtin-function.patch +Patch3079: LoongArch-Add-tests-for-SX-vector-floating-point-ins.patch +Patch3080: LoongArch-Add-tests-for-SX-vector-addition-instructi.patch +Patch3081: LoongArch-Add-tests-for-SX-vector-subtraction-instru.patch +Patch3082: LoongArch-Add-tests-for-SX-vector-addition-vsadd-ins.patch +Patch3083: LoongArch-Add-tests-for-the-SX-vector-multiplication.patch +Patch3084: LoongArch-Add-tests-for-SX-vector-vavg-vavgr-instruc.patch +Patch3085: LoongArch-Add-tests-for-SX-vector-vmax-vmaxi-vmin-vm.patch +Patch3086: LoongArch-Add-tests-for-SX-vector-vexth-vextl-vldi-v.patch +Patch3087: LoongArch-Add-tests-for-SX-vector-vabsd-vmskgez-vmsk.patch +Patch3088: LoongArch-Add-tests-for-SX-vector-vdiv-vmod-instruct.patch +Patch3089: LoongArch-Add-tests-for-SX-vector-vsll-vslli-vsrl-vs.patch +Patch3090: LoongArch-Add-tests-for-SX-vector-vrotr-vrotri-vsra-.patch +Patch3091: LoongArch-Add-tests-for-SX-vector-vssran-vssrani-vss.patch +Patch3092: LoongArch-Add-tests-for-SX-vector-vbitclr-vbitclri-v.patch +Patch3093: LoongArch-Add-tests-for-SX-vector-floating-point-ari.patch +Patch3094: LoongArch-Add-tests-for-SX-vector-vfrstp-vfrstpi-vse.patch +Patch3095: LoongArch-Add-tests-for-SX-vector-vfcmp-instructions.patch +Patch3096: LoongArch-Add-tests-for-SX-vector-handling-and-shuff.patch +Patch3097: LoongArch-Add-tests-for-SX-vector-vand-vandi-vandn-v.patch +Patch3098: LoongArch-Add-tests-for-SX-vector-vfmadd-vfnmadd-vld.patch +Patch3099: LoongArch-Add-tests-for-ASX-vector-xvadd-xvadda-xvad.patch +Patch3100: LoongArch-Add-tests-for-ASX-vector-xvhadd-xvhaddw-xv.patch +Patch3101: LoongArch-Add-tests-for-ASX-vector-subtraction-instr.patch +Patch3102: LoongArch-Add-tests-for-ASX-vector-xvmul-xvmod-xvdiv.patch +Patch3103: LoongArch-Add-tests-for-ASX-vector-xvmax-xvmaxi-xvmi.patch +Patch3104: LoongArch-Add-tests-for-ASX-vector-xvldi-xvmskgez-xv.patch +Patch3105: LoongArch-Add-tests-for-ASX-vector-xvand-xvandi-xvan.patch +Patch3106: LoongArch-Add-tests-for-ASX-vector-xvsll-xvsrl-instr.patch +Patch3107: LoongArch-Add-tests-for-ASX-vector-xvextl-xvsra-xvsr.patch +Patch3108: LoongArch-Add-tests-for-ASX-vector-xvbitclr-xvbitclr.patch +Patch3109: LoongArch-Add-tests-for-ASX-builtin-functions.patch +Patch3110: LoongArch-Add-tests-for-ASX-xvldrepl-xvstelm-instruc.patch +Patch3111: LoongArch-Add-tests-for-ASX-vector-floating-point-op.patch +Patch3112: LoongArch-Add-tests-for-ASX-vector-floating-point-co.patch +Patch3113: LoongArch-Add-tests-for-ASX-vector-comparison-and-se.patch +Patch3114: LoongArch-Add-tests-for-ASX-vector-xvfnmadd-xvfrstp-.patch +Patch3115: LoongArch-Add-tests-for-ASX-vector-xvabsd-xvavg-xvav.patch +Patch3116: LoongArch-Add-tests-for-ASX-vector-xvfcmp-caf-ceq-cl.patch +Patch3117: LoongArch-Add-tests-for-ASX-vector-xvfcmp-saf-seq-sl.patch +Patch3118: LoongArch-Add-tests-for-ASX-vector-xvext2xv-xvexth-x.patch +Patch3119: LoongArch-Add-tests-for-ASX-vector-xvpackev-xvpackod.patch +Patch3120: LoongArch-Add-tests-for-ASX-vector-xvssrln-xvssrlni-.patch +Patch3121: LoongArch-Add-tests-for-ASX-vector-xvssran-xvssrani-.patch +Patch3122: LoongArch-Fix-bug-of-optab-di3_fake.patch +Patch3123: LoongArch-Change-the-value-of-branch_cost-from-2-to-.patch +Patch3124: libsanitizer-add-LoongArch-support.patch +Patch3125: LoongArch-fix-error-building.patch +Patch3126: libjccjit-do-not-link-objects-contained-same-element.patch +%endif + # On ARM EABI systems, we do want -gnueabi to be part of the # target triple. %ifnarch %{arm} @@ -658,6 +790,134 @@ %patch27 -p1 %patch28 -p1 +%ifarch loongarch64 +%patch3001 -p1 +%patch3002 -p1 +%patch3003 -p1 +%patch3004 -p1 +%patch3005 -p1 +%patch3006 -p1 +%patch3007 -p1 +%patch3008 -p1 +%patch3009 -p1 +%patch3010 -p1 +%patch3011 -p1 +%patch3012 -p1 +%patch3013 -p1 +%patch3014 -p1 +%patch3015 -p1 +%patch3016 -p1 +%patch3017 -p1 +%patch3018 -p1 +%patch3019 -p1 +%patch3020 -p1 +%patch3021 -p1 +%patch3022 -p1 +%patch3023 -p1 +%patch3024 -p1 +%patch3025 -p1 +%patch3026 -p1 +%patch3027 -p1 +%patch3028 -p1 +%patch3029 -p1 +%patch3030 -p1 +%patch3031 -p1 +%patch3032 -p1 +%patch3033 -p1 +%patch3034 -p1 +%patch3035 -p1 +%patch3036 -p1 +%patch3037 -p1 +%patch3038 -p1 +%patch3039 -p1 +%patch3040 -p1 +%patch3041 -p1 +%patch3042 -p1 +%patch3043 -p1 +%patch3044 -p1 +%patch3045 -p1 +%patch3046 -p1 +%patch3047 -p1 +%patch3048 -p1 +%patch3049 -p1 +%patch3050 -p1 +%patch3051 -p1 +%patch3052 -p1 +%patch3053 -p1 +%patch3054 -p1 +%patch3056 -p1 +%patch3057 -p1 +%patch3058 -p1 +%patch3059 -p1 +%patch3060 -p1 +%patch3061 -p1 +%patch3062 -p1 +%patch3063 -p1 +%patch3064 -p1 +%patch3065 -p1 +%patch3066 -p1 +%patch3067 -p1 +%patch3068 -p1 +%patch3069 -p1 +%patch3070 -p1 +%patch3071 -p1 +%patch3072 -p1 +%patch3073 -p1 +%patch3074 -p1 +%patch3075 -p1 +%patch3076 -p1 +%patch3077 -p1 +%patch3078 -p1 +%patch3079 -p1 +%patch3080 -p1 +%patch3081 -p1 +%patch3082 -p1 +%patch3083 -p1 +%patch3084 -p1 +%patch3085 -p1 +%patch3086 -p1 +%patch3087 -p1 +%patch3088 -p1 +%patch3089 -p1 +%patch3090 -p1 +%patch3091 -p1 +%patch3092 -p1 +%patch3093 -p1 +%patch3094 -p1 +%patch3095 -p1 +%patch3096 -p1 +%patch3097 -p1 +%patch3098 -p1 +%patch3099 -p1 +%patch3100 -p1 +%patch3101 -p1 +%patch3102 -p1 +%patch3103 -p1 +%patch3104 -p1 +%patch3105 -p1 +%patch3106 -p1 +%patch3107 -p1 +%patch3108 -p1 +%patch3109 -p1 +%patch3110 -p1 +%patch3111 -p1 +%patch3112 -p1 +%patch3113 -p1 +%patch3114 -p1 +%patch3115 -p1 +%patch3116 -p1 +%patch3117 -p1 +%patch3118 -p1 +%patch3119 -p1 +%patch3120 -p1 +%patch3121 -p1 +%patch3122 -p1 +%patch3123 -p1 +%patch3124 -p1 +%patch3125 -p1 +%patch3126 -p1 +%endif + echo '%{_vendor} %{version}-%{release}' > gcc/DEV-PHASE cp -a libstdc++-v3/config/cpu/i{4,3}86/atomicity.h @@ -761,6 +1021,11 @@ %ifnarch sparc sparcv9 ppc --build=%{gcc_target_platform} \ %endif +%ifarch loongarch64 + --with-arch=loongarch64 --with-abi=lp64d \ + --disable-libquadmath --disable-multilib --enable-tls \ + --enable-default-pie +%endif " # Add Secure Compilation Options @@ -1029,7 +1294,7 @@ mv -f %{buildroot}%{_prefix}/%{_lib}/libgcc_s.so.1 %{buildroot}/%{_lib}/libgcc_s-%{gcc_major}.so.1 chmod 755 %{buildroot}/%{_lib}/libgcc_s-%{gcc_major}.so.1 ln -sf libgcc_s-%{gcc_major}.so.1 %{buildroot}/%{_lib}/libgcc_s.so.1 -%ifarch %{ix86} x86_64 ppc ppc64 ppc64p7 ppc64le %{arm} aarch64 riscv64 +%ifarch %{ix86} x86_64 ppc ppc64 ppc64p7 ppc64le %{arm} aarch64 riscv64 loongarch64 rm -f $FULLPATH/libgcc_s.so echo '/* GNU ld script Use the shared library, but some functions are only in @@ -1132,6 +1397,18 @@ %if %{build_libubsan} ln -sf ../../../libubsan.so.1.* libubsan.so %endif +%ifarch loongarch64 +%if %{build_libtsan} +rm -f libtsan.so +echo 'INPUT ( %{_prefix}/%{_lib}/'`echo ../../../../%{_lib}/libtsan.so.2.* | sed 's,^.*libt,libt,'`' )' > libtsan.so +mv ../../../../%{_lib}/libtsan_preinit.o libtsan_preinit.o +%endif +%if %{build_liblsan} +rm -f liblsan.so +echo 'INPUT ( %{_prefix}/%{_lib}/'`echo ../../../../%{_lib}/liblsan.so.0.* | sed 's,^.*libl,libl,'`' )' > liblsan.so +mv ../../../../%{_lib}/liblsan_preinit.o liblsan_preinit.o +%endif +%endif else %if %{build_objc} ln -sf ../../../../%{_lib}/libobjc.so.4 libobjc.so @@ -2077,6 +2354,15 @@ %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/include/arm_bf16.h %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/include/arm_sve.h %endif +%ifarch loongarch64 +%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/include/larchintrin.h +%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/plugin/include/config/loongarch/loongarch-protos.h +%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/plugin/include/config/loongarch/loongarch-opts.h +%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/plugin/include/config/loongarch/loongarch-str.h +%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/plugin/include/config/loongarch/loongarch-def.h +%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/plugin/include/config/loongarch/loongarch-tune.h +%{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/plugin/include/config/loongarch/loongarch-driver.h +%endif %ifarch sparc sparcv9 sparc64 %{_prefix}/lib/gcc/%{gcc_target_platform}/%{gcc_major}/include/visintrin.h %endif @@ -2888,6 +3174,16 @@ %doc rpm.doc/changelogs/libcc1/ChangeLog* %changelog +* Mon Apr 1 2024 Peng Fan <fanpeng@loongson.cn> 12.3.1-19 +- Type: SPEC +- DESC: fix libcc1 file path for LoongArch. + +* Wed Mar 27 2024 Peng Fan <fanpeng@loongson.cn> 12.3.1-18 +- Type: Sync +- DESC: Sync patch from gcc upstream +- LoongArch: support libsanitizer +- separate LoongArch's patch + * Mon Jan 15 2024 laokz <zhangkai@iscas.ac.cn> 12.3.1-17 - Type: SPEC - DESC: riscv64 -march default to rv64gc
View file
_service:tar_scm:Libvtv-Add-loongarch-support.patch
Added
@@ -0,0 +1,59 @@ +From 62ea18c632200edbbf46b4e957bc4d997f1c66f0 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Tue, 27 Sep 2022 15:28:43 +0800 +Subject: PATCH 024/124 Libvtv: Add loongarch support. + +The loongarch64 specification permits page sizes of 4KiB, 16KiB and 64KiB, +but only 16KiB pages are supported for now. + +Co-Authored-By: qijingwen <qijingwen@loongson.cn> + +include/ChangeLog: + + * vtv-change-permission.h (defined): Determines whether the macro + __loongarch_lp64 is defined + (VTV_PAGE_SIZE): Set VTV_PAGE_SIZE to 16KiB for loongarch64. + +libvtv/ChangeLog: + + * configure.tgt: Add loongarch support. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + include/vtv-change-permission.h | 4 ++++ + libvtv/configure.tgt | 3 +++ + 2 files changed, 7 insertions(+) + +diff --git a/include/vtv-change-permission.h b/include/vtv-change-permission.h +index 70bdad92b..e7b9294a0 100644 +--- a/include/vtv-change-permission.h ++++ b/include/vtv-change-permission.h +@@ -48,6 +48,10 @@ extern void __VLTChangePermission (int); + #else + #if defined(__sun__) && defined(__svr4__) && defined(__sparc__) + #define VTV_PAGE_SIZE 8192 ++#elif defined(__loongarch_lp64) ++/* The page size is configurable by the kernel to be 4, 16 or 64 KiB. ++ For now, only the default page size of 16KiB is supported. */ ++#define VTV_PAGE_SIZE 16384 + #else + #define VTV_PAGE_SIZE 4096 + #endif +diff --git a/libvtv/configure.tgt b/libvtv/configure.tgt +index aa2a3f675..6cdd1e97a 100644 +--- a/libvtv/configure.tgt ++++ b/libvtv/configure.tgt +@@ -50,6 +50,9 @@ case "${target}" in + ;; + x86_64-*-darwin1* | i?86-*-darwin1*) + ;; ++ loongarch*-*-linux*) ++ VTV_SUPPORTED=yes ++ ;; + *) + ;; + esac +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-Loongson-ASX-base-instruction-support.patch
Added
@@ -0,0 +1,8376 @@ +From 2f0874e6e6f5a866e71826983dc18295c408748b Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 16 Mar 2023 16:34:08 +0800 +Subject: PATCH 065/124 LoongArch: Add Loongson ASX base instruction support. + +gcc/ChangeLog: + + * config/loongarch/loongarch-modes.def + (VECTOR_MODES): Add Loongson ASX instruction support. + * config/loongarch/loongarch-protos.h (loongarch_split_256bit_move): Ditto. + (loongarch_split_256bit_move_p): Ditto. + (loongarch_expand_vector_group_init): Ditto. + (loongarch_expand_vec_perm_1): Ditto. + * config/loongarch/loongarch.cc (loongarch_symbol_insns): Ditto. + (loongarch_valid_offset_p): Ditto. + (loongarch_address_insns): Ditto. + (loongarch_const_insns): Ditto. + (loongarch_legitimize_move): Ditto. + (loongarch_builtin_vectorization_cost): Ditto. + (loongarch_split_move_p): Ditto. + (loongarch_split_move): Ditto. + (loongarch_output_move_index_float): Ditto. + (loongarch_split_256bit_move_p): Ditto. + (loongarch_split_256bit_move): Ditto. + (loongarch_output_move): Ditto. + (loongarch_print_operand_reloc): Ditto. + (loongarch_print_operand): Ditto. + (loongarch_hard_regno_mode_ok_uncached): Ditto. + (loongarch_hard_regno_nregs): Ditto. + (loongarch_class_max_nregs): Ditto. + (loongarch_can_change_mode_class): Ditto. + (loongarch_mode_ok_for_mov_fmt_p): Ditto. + (loongarch_vector_mode_supported_p): Ditto. + (loongarch_preferred_simd_mode): Ditto. + (loongarch_autovectorize_vector_modes): Ditto. + (loongarch_lsx_output_division): Ditto. + (loongarch_expand_lsx_shuffle): Ditto. + (loongarch_expand_vec_perm): Ditto. + (loongarch_expand_vec_perm_interleave): Ditto. + (loongarch_try_expand_lsx_vshuf_const): Ditto. + (loongarch_expand_vec_perm_even_odd_1): Ditto. + (loongarch_expand_vec_perm_even_odd): Ditto. + (loongarch_expand_vec_perm_1): Ditto. + (loongarch_expand_vec_perm_const_2): Ditto. + (loongarch_is_quad_duplicate): Ditto. + (loongarch_is_double_duplicate): Ditto. + (loongarch_is_odd_extraction): Ditto. + (loongarch_is_even_extraction): Ditto. + (loongarch_is_extraction_permutation): Ditto. + (loongarch_is_center_extraction): Ditto. + (loongarch_is_reversing_permutation): Ditto. + (loongarch_is_di_misalign_extract): Ditto. + (loongarch_is_si_misalign_extract): Ditto. + (loongarch_is_lasx_lowpart_interleave): Ditto. + (loongarch_is_lasx_lowpart_interleave_2): Ditto. + (COMPARE_SELECTOR): Ditto. + (loongarch_is_lasx_lowpart_extract): Ditto. + (loongarch_is_lasx_highpart_interleave): Ditto. + (loongarch_is_lasx_highpart_interleave_2): Ditto. + (loongarch_is_elem_duplicate): Ditto. + (loongarch_is_op_reverse_perm): Ditto. + (loongarch_is_single_op_perm): Ditto. + (loongarch_is_divisible_perm): Ditto. + (loongarch_is_triple_stride_extract): Ditto. + (loongarch_vectorize_vec_perm_const): Ditto. + (loongarch_cpu_sched_reassociation_width): Ditto. + (loongarch_expand_vector_extract): Ditto. + (emit_reduc_half): Ditto. + (loongarch_expand_vec_unpack): Ditto. + (loongarch_expand_vector_group_init): Ditto. + (loongarch_expand_vector_init): Ditto. + (loongarch_expand_lsx_cmp): Ditto. + (loongarch_builtin_support_vector_misalignment): Ditto. + * config/loongarch/loongarch.h (UNITS_PER_LASX_REG): Ditto. + (BITS_PER_LASX_REG): Ditto. + (STRUCTURE_SIZE_BOUNDARY): Ditto. + (LASX_REG_FIRST): Ditto. + (LASX_REG_LAST): Ditto. + (LASX_REG_NUM): Ditto. + (LASX_REG_P): Ditto. + (LASX_REG_RTX_P): Ditto. + (LASX_SUPPORTED_MODE_P): Ditto. + * config/loongarch/loongarch.md: Ditto. + * config/loongarch/lasx.md: New file. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/lasx.md | 5104 ++++++++++++++++++++++ + gcc/config/loongarch/loongarch-modes.def | 1 + + gcc/config/loongarch/loongarch-protos.h | 4 + + gcc/config/loongarch/loongarch.cc | 2567 ++++++++++- + gcc/config/loongarch/loongarch.h | 60 +- + gcc/config/loongarch/loongarch.md | 20 +- + 6 files changed, 7637 insertions(+), 119 deletions(-) + create mode 100644 gcc/config/loongarch/lasx.md + +diff --git a/gcc/config/loongarch/lasx.md b/gcc/config/loongarch/lasx.md +new file mode 100644 +index 000000000..8111c8bb7 +--- /dev/null ++++ b/gcc/config/loongarch/lasx.md +@@ -0,0 +1,5104 @@ ++;; Machine Description for LARCH Loongson ASX ASE ++;; ++;; Copyright (C) 2018 Free Software Foundation, Inc. ++;; ++;; This file is part of GCC. ++;; ++;; GCC is free software; you can redistribute it and/or modify ++;; it under the terms of the GNU General Public License as published by ++;; the Free Software Foundation; either version 3, or (at your option) ++;; any later version. ++;; ++;; GCC is distributed in the hope that it will be useful, ++;; but WITHOUT ANY WARRANTY; without even the implied warranty of ++;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++;; GNU General Public License for more details. ++;; ++;; You should have received a copy of the GNU General Public License ++;; along with GCC; see the file COPYING3. If not see ++;; <http://www.gnu.org/licenses/>. ++;; ++ ++(define_c_enum "unspec" ++ UNSPEC_LASX_XVABSD_S ++ UNSPEC_LASX_XVABSD_U ++ UNSPEC_LASX_XVAVG_S ++ UNSPEC_LASX_XVAVG_U ++ UNSPEC_LASX_XVAVGR_S ++ UNSPEC_LASX_XVAVGR_U ++ UNSPEC_LASX_XVBITCLR ++ UNSPEC_LASX_XVBITCLRI ++ UNSPEC_LASX_XVBITREV ++ UNSPEC_LASX_XVBITREVI ++ UNSPEC_LASX_XVBITSET ++ UNSPEC_LASX_XVBITSETI ++ UNSPEC_LASX_XVFCMP_CAF ++ UNSPEC_LASX_XVFCLASS ++ UNSPEC_LASX_XVFCMP_CUNE ++ UNSPEC_LASX_XVFCVT ++ UNSPEC_LASX_XVFCVTH ++ UNSPEC_LASX_XVFCVTL ++ UNSPEC_LASX_XVFLOGB ++ UNSPEC_LASX_XVFRECIP ++ UNSPEC_LASX_XVFRINT ++ UNSPEC_LASX_XVFRSQRT ++ UNSPEC_LASX_XVFCMP_SAF ++ UNSPEC_LASX_XVFCMP_SEQ ++ UNSPEC_LASX_XVFCMP_SLE ++ UNSPEC_LASX_XVFCMP_SLT ++ UNSPEC_LASX_XVFCMP_SNE ++ UNSPEC_LASX_XVFCMP_SOR ++ UNSPEC_LASX_XVFCMP_SUEQ ++ UNSPEC_LASX_XVFCMP_SULE ++ UNSPEC_LASX_XVFCMP_SULT ++ UNSPEC_LASX_XVFCMP_SUN ++ UNSPEC_LASX_XVFCMP_SUNE ++ UNSPEC_LASX_XVFTINT_S ++ UNSPEC_LASX_XVFTINT_U ++ UNSPEC_LASX_XVCLO ++ UNSPEC_LASX_XVSAT_S ++ UNSPEC_LASX_XVSAT_U ++ UNSPEC_LASX_XVREPLVE0 ++ UNSPEC_LASX_XVREPL128VEI ++ UNSPEC_LASX_XVSRAR ++ UNSPEC_LASX_XVSRARI ++ UNSPEC_LASX_XVSRLR ++ UNSPEC_LASX_XVSRLRI ++ UNSPEC_LASX_XVSHUF ++ UNSPEC_LASX_XVSHUF_B ++ UNSPEC_LASX_BRANCH ++ UNSPEC_LASX_BRANCH_V ++ ++ UNSPEC_LASX_XVMUH_S ++ UNSPEC_LASX_XVMUH_U ++ UNSPEC_LASX_MXVEXTW_U ++ UNSPEC_LASX_XVSLLWIL_S ++ UNSPEC_LASX_XVSLLWIL_U ++ UNSPEC_LASX_XVSRAN ++ UNSPEC_LASX_XVSSRAN_S ++ UNSPEC_LASX_XVSSRAN_U ++ UNSPEC_LASX_XVSRARN ++ UNSPEC_LASX_XVSSRARN_S ++ UNSPEC_LASX_XVSSRARN_U ++ UNSPEC_LASX_XVSRLN ++ UNSPEC_LASX_XVSSRLN_U ++ UNSPEC_LASX_XVSRLRN ++ UNSPEC_LASX_XVSSRLRN_U ++ UNSPEC_LASX_XVFRSTPI ++ UNSPEC_LASX_XVFRSTP ++ UNSPEC_LASX_XVSHUF4I ++ UNSPEC_LASX_XVBSRL_V ++ UNSPEC_LASX_XVBSLL_V ++ UNSPEC_LASX_XVEXTRINS ++ UNSPEC_LASX_XVMSKLTZ ++ UNSPEC_LASX_XVSIGNCOV ++ UNSPEC_LASX_XVFTINTRNE_W_S ++ UNSPEC_LASX_XVFTINTRNE_L_D ++ UNSPEC_LASX_XVFTINTRP_W_S ++ UNSPEC_LASX_XVFTINTRP_L_D ++ UNSPEC_LASX_XVFTINTRM_W_S ++ UNSPEC_LASX_XVFTINTRM_L_D ++ UNSPEC_LASX_XVFTINT_W_D ++ UNSPEC_LASX_XVFFINT_S_L ++ UNSPEC_LASX_XVFTINTRZ_W_D ++ UNSPEC_LASX_XVFTINTRP_W_D ++ UNSPEC_LASX_XVFTINTRM_W_D ++ UNSPEC_LASX_XVFTINTRNE_W_D ++ UNSPEC_LASX_XVFTINTH_L_S ++ UNSPEC_LASX_XVFTINTL_L_S ++ UNSPEC_LASX_XVFFINTH_D_W ++ UNSPEC_LASX_XVFFINTL_D_W ++ UNSPEC_LASX_XVFTINTRZH_L_S ++ UNSPEC_LASX_XVFTINTRZL_L_S ++ UNSPEC_LASX_XVFTINTRPH_L_S ++ UNSPEC_LASX_XVFTINTRPL_L_S ++ UNSPEC_LASX_XVFTINTRMH_L_S ++ UNSPEC_LASX_XVFTINTRML_L_S ++ UNSPEC_LASX_XVFTINTRNEL_L_S ++ UNSPEC_LASX_XVFTINTRNEH_L_S ++ UNSPEC_LASX_XVFRINTRNE_S ++ UNSPEC_LASX_XVFRINTRNE_D ++ UNSPEC_LASX_XVFRINTRZ_S ++ UNSPEC_LASX_XVFRINTRZ_D ++ UNSPEC_LASX_XVFRINTRP_S ++ UNSPEC_LASX_XVFRINTRP_D ++ UNSPEC_LASX_XVFRINTRM_S ++ UNSPEC_LASX_XVFRINTRM_D ++ UNSPEC_LASX_XVREPLVE0_Q ++ UNSPEC_LASX_XVPERM_W ++ UNSPEC_LASX_XVPERMI_Q ++ UNSPEC_LASX_XVPERMI_D ++ ++ UNSPEC_LASX_XVADDWEV ++ UNSPEC_LASX_XVADDWEV2 ++ UNSPEC_LASX_XVADDWEV3 ++ UNSPEC_LASX_XVSUBWEV ++ UNSPEC_LASX_XVSUBWEV2 ++ UNSPEC_LASX_XVMULWEV ++ UNSPEC_LASX_XVMULWEV2 ++ UNSPEC_LASX_XVMULWEV3 ++ UNSPEC_LASX_XVADDWOD ++ UNSPEC_LASX_XVADDWOD2 ++ UNSPEC_LASX_XVADDWOD3 ++ UNSPEC_LASX_XVSUBWOD ++ UNSPEC_LASX_XVSUBWOD2 ++ UNSPEC_LASX_XVMULWOD ++ UNSPEC_LASX_XVMULWOD2 ++ UNSPEC_LASX_XVMULWOD3 ++ UNSPEC_LASX_XVMADDWEV ++ UNSPEC_LASX_XVMADDWEV2 ++ UNSPEC_LASX_XVMADDWEV3 ++ UNSPEC_LASX_XVMADDWOD ++ UNSPEC_LASX_XVMADDWOD2 ++ UNSPEC_LASX_XVMADDWOD3 ++ UNSPEC_LASX_XVHADDW_Q_D ++ UNSPEC_LASX_XVHSUBW_Q_D ++ UNSPEC_LASX_XVHADDW_QU_DU ++ UNSPEC_LASX_XVHSUBW_QU_DU ++ UNSPEC_LASX_XVROTR ++ UNSPEC_LASX_XVADD_Q ++ UNSPEC_LASX_XVSUB_Q ++ UNSPEC_LASX_XVREPLVE ++ UNSPEC_LASX_XVSHUF4 ++ UNSPEC_LASX_XVMSKGEZ ++ UNSPEC_LASX_XVMSKNZ ++ UNSPEC_LASX_XVEXTH_Q_D ++ UNSPEC_LASX_XVEXTH_QU_DU ++ UNSPEC_LASX_XVEXTL_Q_D ++ UNSPEC_LASX_XVSRLNI ++ UNSPEC_LASX_XVSRLRNI ++ UNSPEC_LASX_XVSSRLNI ++ UNSPEC_LASX_XVSSRLNI2 ++ UNSPEC_LASX_XVSSRLRNI ++ UNSPEC_LASX_XVSSRLRNI2 ++ UNSPEC_LASX_XVSRANI ++ UNSPEC_LASX_XVSRARNI ++ UNSPEC_LASX_XVSSRANI ++ UNSPEC_LASX_XVSSRANI2 ++ UNSPEC_LASX_XVSSRARNI ++ UNSPEC_LASX_XVSSRARNI2 ++ UNSPEC_LASX_XVPERMI ++ UNSPEC_LASX_XVINSVE0 ++ UNSPEC_LASX_XVPICKVE ++ UNSPEC_LASX_XVSSRLN ++ UNSPEC_LASX_XVSSRLRN ++ UNSPEC_LASX_XVEXTL_QU_DU ++ UNSPEC_LASX_XVLDI ++ UNSPEC_LASX_XVLDX ++ UNSPEC_LASX_XVSTX ++) ++ ++;; All vector modes with 256 bits. ++(define_mode_iterator LASX V4DF V8SF V4DI V8SI V16HI V32QI) ++ ++;; Same as LASX. Used by vcond to iterate two modes. ++(define_mode_iterator LASX_2 V4DF V8SF V4DI V8SI V16HI V32QI) ++ ++;; Only used for splitting insert_d and copy_{u,s}.d. ++(define_mode_iterator LASX_D V4DI V4DF) ++ ++;; Only used for splitting insert_d and copy_{u,s}.d. ++(define_mode_iterator LASX_WD V4DI V4DF V8SI V8SF) ++ ++;; Only used for copy256_{u,s}.w. ++(define_mode_iterator LASX_W V8SI V8SF) ++ ++;; Only integer modes in LASX. ++(define_mode_iterator ILASX V4DI V8SI V16HI V32QI) ++ ++;; As ILASX but excludes V32QI. ++(define_mode_iterator ILASX_DWH V4DI V8SI V16HI) ++ ++;; As LASX but excludes V32QI. ++(define_mode_iterator LASX_DWH V4DF V8SF V4DI V8SI V16HI) ++ ++;; As ILASX but excludes V4DI. ++(define_mode_iterator ILASX_WHB V8SI V16HI V32QI) ++ ++;; Only integer modes equal or larger than a word. ++(define_mode_iterator ILASX_DW V4DI V8SI) ++ ++;; Only integer modes smaller than a word. ++(define_mode_iterator ILASX_HB V16HI V32QI) ++ ++;; Only floating-point modes in LASX. ++(define_mode_iterator FLASX V4DF V8SF) ++ ++;; Only used for immediate set shuffle elements instruction. ++(define_mode_iterator LASX_WHB_W V8SI V16HI V32QI V8SF) ++ ++;; The attribute gives the integer vector mode with same size in Loongson ASX. ++(define_mode_attr VIMODE256 ++ (V4DF "V4DI") ++ (V8SF "V8SI") ++ (V4DI "V4DI") ++ (V8SI "V8SI") ++ (V16HI "V16HI") ++ (V32QI "V32QI")) ++ ++;;attribute gives half modes for vector modes. ++;;attribute gives half modes (Same Size) for vector modes. ++(define_mode_attr VHSMODE256 ++ (V16HI "V32QI") ++ (V8SI "V16HI") ++ (V4DI "V8SI")) ++ ++;;attribute gives half modes for vector modes. ++(define_mode_attr VHMODE256 ++ (V32QI "V16QI") ++ (V16HI "V8HI") ++ (V8SI "V4SI") ++ (V4DI "V2DI")) ++ ++;;attribute gives half float modes for vector modes. ++(define_mode_attr VFHMODE256 ++ (V8SF "V4SF") ++ (V4DF "V2DF")) ++ ++;; The attribute gives double modes for vector modes in LASX. ++(define_mode_attr VDMODE256 ++ (V8SI "V4DI") ++ (V16HI "V8SI") ++ (V32QI "V16HI")) ++ ++;; extended from VDMODE256 ++(define_mode_attr VDMODEEXD256 ++ (V4DI "V4DI") ++ (V8SI "V4DI") ++ (V16HI "V8SI") ++ (V32QI "V16HI")) ++ ++;; The attribute gives half modes with same number of elements for vector modes. ++(define_mode_attr VTRUNCMODE256 ++ (V16HI "V16QI") ++ (V8SI "V8HI") ++ (V4DI "V4SI")) ++ ++;; Double-sized Vector MODE with same elemet type. "Vector, Enlarged-MODE" ++(define_mode_attr VEMODE256 ++ (V8SF "V16SF") ++ (V8SI "V16SI") ++ (V4DF "V8DF") ++ (V4DI "V8DI")) ++ ++;; This attribute gives the mode of the result for "copy_s_b, copy_u_b" etc. ++(define_mode_attr VRES256 ++ (V4DF "DF") ++ (V8SF "SF") ++ (V4DI "DI") ++ (V8SI "SI") ++ (V16HI "SI") ++ (V32QI "SI")) ++ ++;; Only used with LASX_D iterator. ++(define_mode_attr lasx_d ++ (V4DI "reg_or_0") ++ (V4DF "register")) ++ ++;; This attribute gives the 256 bit integer vector mode with same size. ++(define_mode_attr mode256_i ++ (V4DF "v4di") ++ (V8SF "v8si") ++ (V4DI "v4di") ++ (V8SI "v8si") ++ (V16HI "v16hi") ++ (V32QI "v32qi")) ++ ++ ++;; This attribute gives the 256 bit float vector mode with same size. ++(define_mode_attr mode256_f ++ (V4DF "v4df") ++ (V8SF "v8sf") ++ (V4DI "v4df") ++ (V8SI "v8sf")) ++ ++ ;; This attribute gives suffix for LASX instructions. HOW? ++(define_mode_attr lasxfmt ++ (V4DF "d") ++ (V8SF "w") ++ (V4DI "d") ++ (V8SI "w") ++ (V16HI "h") ++ (V32QI "b")) ++ ++(define_mode_attr flasxfmt ++ (V4DF "d") ++ (V8SF "s")) ++ ++(define_mode_attr lasxfmt_u ++ (V4DF "du") ++ (V8SF "wu") ++ (V4DI "du") ++ (V8SI "wu") ++ (V16HI "hu") ++ (V32QI "bu")) ++ ++(define_mode_attr ilasxfmt ++ (V4DF "l") ++ (V8SF "w")) ++ ++(define_mode_attr ilasxfmt_u ++ (V4DF "lu") ++ (V8SF "wu")) ++ ++;; This attribute gives suffix for integers in VHMODE256. ++(define_mode_attr hlasxfmt ++ (V4DI "w") ++ (V8SI "h") ++ (V16HI "b")) ++ ++(define_mode_attr hlasxfmt_u ++ (V4DI "wu") ++ (V8SI "hu") ++ (V16HI "bu")) ++ ++;; This attribute gives suffix for integers in VHSMODE256. ++(define_mode_attr hslasxfmt ++ (V4DI "w") ++ (V8SI "h") ++ (V16HI "b")) ++ ++;; This attribute gives define_insn suffix for LASX instructions that need ++;; distinction between integer and floating point. ++(define_mode_attr lasxfmt_f ++ (V4DF "d_f") ++ (V8SF "w_f") ++ (V4DI "d") ++ (V8SI "w") ++ (V16HI "h") ++ (V32QI "b")) ++ ++(define_mode_attr flasxfmt_f ++ (V4DF "d_f") ++ (V8SF "s_f") ++ (V4DI "d") ++ (V8SI "w") ++ (V16HI "h") ++ (V32QI "b")) ++ ++;; This attribute gives define_insn suffix for LASX instructions that need ++;; distinction between integer and floating point. ++(define_mode_attr lasxfmt_f_wd ++ (V4DF "d_f") ++ (V8SF "w_f") ++ (V4DI "d") ++ (V8SI "w")) ++ ++;; This attribute gives suffix for integers in VHMODE256. ++(define_mode_attr dlasxfmt ++ (V8SI "d") ++ (V16HI "w") ++ (V32QI "h")) ++ ++(define_mode_attr dlasxfmt_u ++ (V8SI "du") ++ (V16HI "wu") ++ (V32QI "hu")) ++ ++;; for VDMODEEXD256 ++(define_mode_attr dlasxqfmt ++ (V4DI "q") ++ (V8SI "d") ++ (V16HI "w") ++ (V32QI "h")) ++ ++;; This is used to form an immediate operand constraint using ++;; "const_<indeximm256>_operand". ++(define_mode_attr indeximm256 ++ (V4DF "0_to_3") ++ (V8SF "0_to_7") ++ (V4DI "0_to_3") ++ (V8SI "0_to_7") ++ (V16HI "uimm4") ++ (V32QI "uimm5")) ++ ++;; This is used to form an immediate operand constraint using to ref high half ++;; "const_<indeximm_hi>_operand". ++(define_mode_attr indeximm_hi ++ (V4DF "2_or_3") ++ (V8SF "4_to_7") ++ (V4DI "2_or_3") ++ (V8SI "4_to_7") ++ (V16HI "8_to_15") ++ (V32QI "16_to_31")) ++ ++;; This is used to form an immediate operand constraint using to ref low half ++;; "const_<indeximm_lo>_operand". ++(define_mode_attr indeximm_lo ++ (V4DF "0_or_1") ++ (V8SF "0_to_3") ++ (V4DI "0_or_1") ++ (V8SI "0_to_3") ++ (V16HI "uimm3") ++ (V32QI "uimm4")) ++ ++;; This attribute represents bitmask needed for vec_merge using in lasx ++;; "const_<bitmask256>_operand". ++(define_mode_attr bitmask256 ++ (V4DF "exp_4") ++ (V8SF "exp_8") ++ (V4DI "exp_4") ++ (V8SI "exp_8") ++ (V16HI "exp_16") ++ (V32QI "exp_32")) ++ ++;; This attribute represents bitmask needed for vec_merge using to ref low half ++;; "const_<bitmask_lo>_operand". ++(define_mode_attr bitmask_lo ++ (V4DF "exp_2") ++ (V8SF "exp_4") ++ (V4DI "exp_2") ++ (V8SI "exp_4") ++ (V16HI "exp_8") ++ (V32QI "exp_16")) ++ ++ ++;; This attribute is used to form an immediate operand constraint using ++;; "const_<bitimm256>_operand". ++(define_mode_attr bitimm256 ++ (V32QI "uimm3") ++ (V16HI "uimm4") ++ (V8SI "uimm5") ++ (V4DI "uimm6")) ++ ++ ++(define_mode_attr d2lasxfmt ++ (V8SI "q") ++ (V16HI "d") ++ (V32QI "w")) ++ ++(define_mode_attr d2lasxfmt_u ++ (V8SI "qu") ++ (V16HI "du") ++ (V32QI "wu")) ++ ++(define_mode_attr VD2MODE256 ++ (V8SI "V4DI") ++ (V16HI "V4DI") ++ (V32QI "V8SI")) ++ ++(define_mode_attr lasxfmt_wd ++ (V4DI "d") ++ (V8SI "w") ++ (V16HI "w") ++ (V32QI "w")) ++ ++(define_int_iterator FRINT256_S UNSPEC_LASX_XVFRINTRP_S ++ UNSPEC_LASX_XVFRINTRZ_S ++ UNSPEC_LASX_XVFRINT ++ UNSPEC_LASX_XVFRINTRM_S) ++ ++(define_int_iterator FRINT256_D UNSPEC_LASX_XVFRINTRP_D ++ UNSPEC_LASX_XVFRINTRZ_D ++ UNSPEC_LASX_XVFRINT ++ UNSPEC_LASX_XVFRINTRM_D) ++ ++(define_int_attr frint256_pattern_s ++ (UNSPEC_LASX_XVFRINTRP_S "ceil") ++ (UNSPEC_LASX_XVFRINTRZ_S "btrunc") ++ (UNSPEC_LASX_XVFRINT "rint") ++ (UNSPEC_LASX_XVFRINTRM_S "floor")) ++ ++(define_int_attr frint256_pattern_d ++ (UNSPEC_LASX_XVFRINTRP_D "ceil") ++ (UNSPEC_LASX_XVFRINTRZ_D "btrunc") ++ (UNSPEC_LASX_XVFRINT "rint") ++ (UNSPEC_LASX_XVFRINTRM_D "floor")) ++ ++(define_int_attr frint256_suffix ++ (UNSPEC_LASX_XVFRINTRP_S "rp") ++ (UNSPEC_LASX_XVFRINTRP_D "rp") ++ (UNSPEC_LASX_XVFRINTRZ_S "rz") ++ (UNSPEC_LASX_XVFRINTRZ_D "rz") ++ (UNSPEC_LASX_XVFRINT "") ++ (UNSPEC_LASX_XVFRINTRM_S "rm") ++ (UNSPEC_LASX_XVFRINTRM_D "rm")) ++ ++(define_expand "vec_init<mode><unitmode>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand:LASX 1 "") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vector_init (operands0, operands1); ++ DONE; ++}) ++ ++(define_expand "vec_initv32qiv16qi" ++ (match_operand:V32QI 0 "register_operand") ++ (match_operand:V16QI 1 "") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vector_group_init (operands0, operands1); ++ DONE; ++}) ++ ++;; FIXME: Delete. ++(define_insn "vec_pack_trunc_<mode>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (vec_concat:<VHSMODE256> ++ (truncate:<VTRUNCMODE256> ++ (match_operand:ILASX_DWH 1 "register_operand" "f")) ++ (truncate:<VTRUNCMODE256> ++ (match_operand:ILASX_DWH 2 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvpickev.<hslasxfmt>\t%u0,%u2,%u1\n\txvpermi.d\t%u0,%u0,0xd8" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "8")) ++ ++(define_expand "vec_unpacks_hi_v8sf" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (float_extend:V4DF ++ (vec_select:V4SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (match_dup 2)))) ++ "ISA_HAS_LASX" ++{ ++ operands2 = loongarch_lsx_vec_parallel_const_half (V8SFmode, ++ true/*high_p*/); ++}) ++ ++(define_expand "vec_unpacks_lo_v8sf" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (float_extend:V4DF ++ (vec_select:V4SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (match_dup 2)))) ++ "ISA_HAS_LASX" ++{ ++ operands2 = loongarch_lsx_vec_parallel_const_half (V8SFmode, ++ false/*high_p*/); ++}) ++ ++(define_expand "vec_unpacks_hi_<mode>" ++ (match_operand:<VDMODE256> 0 "register_operand") ++ (match_operand:ILASX_WHB 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vec_unpack (operands, false/*unsigned_p*/, ++ true/*high_p*/); ++ DONE; ++}) ++ ++(define_expand "vec_unpacks_lo_<mode>" ++ (match_operand:<VDMODE256> 0 "register_operand") ++ (match_operand:ILASX_WHB 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vec_unpack (operands, false/*unsigned_p*/, false/*high_p*/); ++ DONE; ++}) ++ ++(define_expand "vec_unpacku_hi_<mode>" ++ (match_operand:<VDMODE256> 0 "register_operand") ++ (match_operand:ILASX_WHB 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vec_unpack (operands, true/*unsigned_p*/, true/*high_p*/); ++ DONE; ++}) ++ ++(define_expand "vec_unpacku_lo_<mode>" ++ (match_operand:<VDMODE256> 0 "register_operand") ++ (match_operand:ILASX_WHB 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vec_unpack (operands, true/*unsigned_p*/, false/*high_p*/); ++ DONE; ++}) ++ ++(define_insn "lasx_xvinsgr2vr_<lasxfmt_f_wd>" ++ (set (match_operand:ILASX_DW 0 "register_operand" "=f") ++ (vec_merge:ILASX_DW ++ (vec_duplicate:ILASX_DW ++ (match_operand:<UNITMODE> 1 "reg_or_0_operand" "rJ")) ++ (match_operand:ILASX_DW 2 "register_operand" "0") ++ (match_operand 3 "const_<bitmask256>_operand" ""))) ++ "ISA_HAS_LASX" ++{ ++#if 0 ++ if (!TARGET_64BIT && (<MODE>mode == V4DImode || <MODE>mode == V4DFmode)) ++ return "#"; ++ else ++#endif ++ return "xvinsgr2vr.<lasxfmt>\t%u0,%z1,%y3"; ++} ++ (set_attr "type" "simd_insert") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "vec_concatv4di" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (vec_concat:V4DI ++ (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return "xvpermi.q\t%u0,%u2,0x20"; ++} ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "vec_concatv8si" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (vec_concat:V8SI ++ (match_operand:V4SI 1 "register_operand" "0") ++ (match_operand:V4SI 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return "xvpermi.q\t%u0,%u2,0x20"; ++} ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "vec_concatv16hi" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_concat:V16HI ++ (match_operand:V8HI 1 "register_operand" "0") ++ (match_operand:V8HI 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return "xvpermi.q\t%u0,%u2,0x20"; ++} ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "vec_concatv32qi" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_concat:V32QI ++ (match_operand:V16QI 1 "register_operand" "0") ++ (match_operand:V16QI 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return "xvpermi.q\t%u0,%u2,0x20"; ++} ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "vec_concatv4df" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (vec_concat:V4DF ++ (match_operand:V2DF 1 "register_operand" "0") ++ (match_operand:V2DF 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return "xvpermi.q\t%u0,%u2,0x20"; ++} ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "vec_concatv8sf" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (vec_concat:V8SF ++ (match_operand:V4SF 1 "register_operand" "0") ++ (match_operand:V4SF 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return "xvpermi.q\t%u0,%u2,0x20"; ++} ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V4DI")) ++ ++;; xshuf.w ++(define_insn "lasx_xvperm_<lasxfmt_f_wd>" ++ (set (match_operand:LASX_W 0 "register_operand" "=f") ++ (unspec:LASX_W ++ (match_operand:LASX_W 1 "nonimmediate_operand" "f") ++ (match_operand:V8SI 2 "register_operand" "f") ++ UNSPEC_LASX_XVPERM_W)) ++ "ISA_HAS_LASX" ++ "xvperm.w\t%u0,%u1,%u2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++;; xvpermi.d ++(define_insn "lasx_xvpermi_d_<LASX:mode>" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (unspec:LASX ++ (match_operand:LASX 1 "register_operand" "f") ++ (match_operand:SI 2 "const_uimm8_operand") ++ UNSPEC_LASX_XVPERMI_D)) ++ "ISA_HAS_LASX" ++ "xvpermi.d\t%u0,%u1,%2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvpermi_d_<mode>_1" ++ (set (match_operand:LASX_D 0 "register_operand" "=f") ++ (vec_select:LASX_D ++ (match_operand:LASX_D 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_0_to_3_operand") ++ (match_operand 3 "const_0_to_3_operand") ++ (match_operand 4 "const_0_to_3_operand") ++ (match_operand 5 "const_0_to_3_operand")))) ++ "ISA_HAS_LASX" ++{ ++ int mask = 0; ++ mask |= INTVAL (operands2) << 0; ++ mask |= INTVAL (operands3) << 2; ++ mask |= INTVAL (operands4) << 4; ++ mask |= INTVAL (operands5) << 6; ++ operands2 = GEN_INT (mask); ++ return "xvpermi.d\t%u0,%u1,%2"; ++} ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++;; xvpermi.q ++(define_insn "lasx_xvpermi_q_<LASX:mode>" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (unspec:LASX ++ (match_operand:LASX 1 "register_operand" "0") ++ (match_operand:LASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand") ++ UNSPEC_LASX_XVPERMI_Q)) ++ "ISA_HAS_LASX" ++ "xvpermi.q\t%u0,%u2,%3" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvpickve2gr_d<u>" ++ (set (match_operand:DI 0 "register_operand" "=r") ++ (any_extend:DI ++ (vec_select:DI ++ (match_operand:V4DI 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_0_to_3_operand" ""))))) ++ "ISA_HAS_LASX" ++ "xvpickve2gr.d<u>\t%0,%u1,%2" ++ (set_attr "type" "simd_copy") ++ (set_attr "mode" "V4DI")) ++ ++(define_expand "vec_set<mode>" ++ (match_operand:ILASX_DW 0 "register_operand") ++ (match_operand:<UNITMODE> 1 "reg_or_0_operand") ++ (match_operand 2 "const_<indeximm256>_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx index = GEN_INT (1 << INTVAL (operands2)); ++ emit_insn (gen_lasx_xvinsgr2vr_<lasxfmt_f_wd> (operands0, operands1, ++ operands0, index)); ++ DONE; ++}) ++ ++(define_expand "vec_set<mode>" ++ (match_operand:FLASX 0 "register_operand") ++ (match_operand:<UNITMODE> 1 "reg_or_0_operand") ++ (match_operand 2 "const_<indeximm256>_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx index = GEN_INT (1 << INTVAL (operands2)); ++ emit_insn (gen_lasx_xvinsve0_<lasxfmt_f>_scalar (operands0, operands1, ++ operands0, index)); ++ DONE; ++}) ++ ++(define_expand "vec_extract<mode><unitmode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:LASX 1 "register_operand") ++ (match_operand 2 "const_<indeximm256>_operand") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vector_extract (operands0, operands1, ++ INTVAL (operands2)); ++ DONE; ++}) ++ ++(define_expand "vec_perm<mode>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand:LASX 1 "register_operand") ++ (match_operand:LASX 2 "register_operand") ++ (match_operand:<VIMODE256> 3 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vec_perm_1 (operands); ++ DONE; ++}) ++ ++;; FIXME: 256?? ++(define_expand "vcondu<LASX:mode><ILASX:mode>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand:LASX 1 "reg_or_m1_operand") ++ (match_operand:LASX 2 "reg_or_0_operand") ++ (match_operator 3 "" ++ (match_operand:ILASX 4 "register_operand") ++ (match_operand:ILASX 5 "register_operand")) ++ "ISA_HAS_LASX ++ && (GET_MODE_NUNITS (<LASX:MODE>mode) ++ == GET_MODE_NUNITS (<ILASX:MODE>mode))" ++{ ++ loongarch_expand_vec_cond_expr (<LASX:MODE>mode, <LASX:VIMODE256>mode, ++ operands); ++ DONE; ++}) ++ ++;; FIXME: 256?? ++(define_expand "vcond<LASX:mode><LASX_2:mode>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand:LASX 1 "reg_or_m1_operand") ++ (match_operand:LASX 2 "reg_or_0_operand") ++ (match_operator 3 "" ++ (match_operand:LASX_2 4 "register_operand") ++ (match_operand:LASX_2 5 "register_operand")) ++ "ISA_HAS_LASX ++ && (GET_MODE_NUNITS (<LASX:MODE>mode) ++ == GET_MODE_NUNITS (<LASX_2:MODE>mode))" ++{ ++ loongarch_expand_vec_cond_expr (<LASX:MODE>mode, <LASX:VIMODE256>mode, ++ operands); ++ DONE; ++}) ++ ++;; Same as vcond_ ++(define_expand "vcond_mask_<ILASX:mode><ILASX:mode>" ++ (match_operand:ILASX 0 "register_operand") ++ (match_operand:ILASX 1 "reg_or_m1_operand") ++ (match_operand:ILASX 2 "reg_or_0_operand") ++ (match_operand:ILASX 3 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ loongarch_expand_vec_cond_mask_expr (<ILASX:MODE>mode, ++ <ILASX:VIMODE256>mode, operands); ++ DONE; ++}) ++ ++(define_expand "lasx_xvrepli<mode>" ++ (match_operand:ILASX 0 "register_operand") ++ (match_operand 1 "const_imm10_operand") ++ "ISA_HAS_LASX" ++{ ++ if (<MODE>mode == V32QImode) ++ operands1 = GEN_INT (trunc_int_for_mode (INTVAL (operands1), ++ <UNITMODE>mode)); ++ emit_move_insn (operands0, ++ loongarch_gen_const_int_vector (<MODE>mode, INTVAL (operands1))); ++ DONE; ++}) ++ ++(define_expand "mov<mode>" ++ (set (match_operand:LASX 0) ++ (match_operand:LASX 1)) ++ "ISA_HAS_LASX" ++{ ++ if (loongarch_legitimize_move (<MODE>mode, operands0, operands1)) ++ DONE; ++}) ++ ++ ++(define_expand "movmisalign<mode>" ++ (set (match_operand:LASX 0) ++ (match_operand:LASX 1)) ++ "ISA_HAS_LASX" ++{ ++ if (loongarch_legitimize_move (<MODE>mode, operands0, operands1)) ++ DONE; ++}) ++ ++;; 256-bit LASX modes can only exist in LASX registers or memory. ++(define_insn "mov<mode>_lasx" ++ (set (match_operand:LASX 0 "nonimmediate_operand" "=f,f,R,*r,*f") ++ (match_operand:LASX 1 "move_operand" "fYGYI,R,f,*f,*r")) ++ "ISA_HAS_LASX" ++ { return loongarch_output_move (operands0, operands1); } ++ (set_attr "type" "simd_move,simd_load,simd_store,simd_copy,simd_insert") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "8,4,4,4,4")) ++ ++ ++(define_split ++ (set (match_operand:LASX 0 "nonimmediate_operand") ++ (match_operand:LASX 1 "move_operand")) ++ "reload_completed && ISA_HAS_LASX ++ && loongarch_split_move_insn_p (operands0, operands1)" ++ (const_int 0) ++{ ++ loongarch_split_move_insn (operands0, operands1, curr_insn); ++ DONE; ++}) ++ ++;; Offset load ++(define_expand "lasx_mxld_<lasxfmt_f>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq10<lasxfmt>_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (operands0, gen_rtx_MEM (<MODE>mode, addr)); ++ DONE; ++}) ++ ++;; Offset store ++(define_expand "lasx_mxst_<lasxfmt_f>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq10<lasxfmt>_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (gen_rtx_MEM (<MODE>mode, addr), operands0); ++ DONE; ++}) ++ ++;; LASX ++(define_insn "add<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f,f") ++ (plus:ILASX ++ (match_operand:ILASX 1 "register_operand" "f,f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_ximm5_operand" "f,Unv5,Uuv5"))) ++ "ISA_HAS_LASX" ++{ ++ switch (which_alternative) ++ { ++ case 0: ++ return "xvadd.<lasxfmt>\t%u0,%u1,%u2"; ++ case 1: ++ { ++ HOST_WIDE_INT val = INTVAL (CONST_VECTOR_ELT (operands2, 0)); ++ ++ operands2 = GEN_INT (-val); ++ return "xvsubi.<lasxfmt_u>\t%u0,%u1,%d2"; ++ } ++ case 2: ++ return "xvaddi.<lasxfmt_u>\t%u0,%u1,%E2"; ++ default: ++ gcc_unreachable (); ++ } ++} ++ (set_attr "alu_type" "simd_add") ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "sub<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (minus:ILASX ++ (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_uimm5_operand" "f,Uuv5"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvsub.<lasxfmt>\t%u0,%u1,%u2 ++ xvsubi.<lasxfmt_u>\t%u0,%u1,%E2" ++ (set_attr "alu_type" "simd_add") ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "mul<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (mult:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvmul.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_mul") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvmadd_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (plus:ILASX (mult:ILASX (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand:ILASX 3 "register_operand" "f")) ++ (match_operand:ILASX 1 "register_operand" "0"))) ++ "ISA_HAS_LASX" ++ "xvmadd.<lasxfmt>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_mul") ++ (set_attr "mode" "<MODE>")) ++ ++ ++ ++(define_insn "lasx_xvmsub_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (minus:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (mult:ILASX (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand:ILASX 3 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvmsub.<lasxfmt>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_mul") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "div<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (div:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return loongarch_lsx_output_division ("xvdiv.<lasxfmt>\t%u0,%u1,%u2", ++ operands); ++} ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "udiv<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (udiv:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return loongarch_lsx_output_division ("xvdiv.<lasxfmt_u>\t%u0,%u1,%u2", ++ operands); ++} ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "mod<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (mod:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return loongarch_lsx_output_division ("xvmod.<lasxfmt>\t%u0,%u1,%u2", ++ operands); ++} ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "umod<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (umod:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++{ ++ return loongarch_lsx_output_division ("xvmod.<lasxfmt_u>\t%u0,%u1,%u2", ++ operands); ++} ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "xor<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f,f") ++ (xor:ILASX ++ (match_operand:ILASX 1 "register_operand" "f,f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_val_operand" "f,YC,Urv8"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvxor.v\t%u0,%u1,%u2 ++ xvbitrevi.%v0\t%u0,%u1,%V2 ++ xvxori.b\t%u0,%u1,%B2" ++ (set_attr "type" "simd_logic,simd_bit,simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "ior<mode>3" ++ (set (match_operand:LASX 0 "register_operand" "=f,f,f") ++ (ior:LASX ++ (match_operand:LASX 1 "register_operand" "f,f,f") ++ (match_operand:LASX 2 "reg_or_vector_same_val_operand" "f,YC,Urv8"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvor.v\t%u0,%u1,%u2 ++ xvbitseti.%v0\t%u0,%u1,%V2 ++ xvori.b\t%u0,%u1,%B2" ++ (set_attr "type" "simd_logic,simd_bit,simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "and<mode>3" ++ (set (match_operand:LASX 0 "register_operand" "=f,f,f") ++ (and:LASX ++ (match_operand:LASX 1 "register_operand" "f,f,f") ++ (match_operand:LASX 2 "reg_or_vector_same_val_operand" "f,YZ,Urv8"))) ++ "ISA_HAS_LASX" ++{ ++ switch (which_alternative) ++ { ++ case 0: ++ return "xvand.v\t%u0,%u1,%u2"; ++ case 1: ++ { ++ rtx elt0 = CONST_VECTOR_ELT (operands2, 0); ++ unsigned HOST_WIDE_INT val = ~UINTVAL (elt0); ++ operands2 = loongarch_gen_const_int_vector (<MODE>mode, val & (-val)); ++ return "xvbitclri.%v0\t%u0,%u1,%V2"; ++ } ++ case 2: ++ return "xvandi.b\t%u0,%u1,%B2"; ++ default: ++ gcc_unreachable (); ++ } ++} ++ (set_attr "type" "simd_logic,simd_bit,simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "one_cmpl<mode>2" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (not:ILASX (match_operand:ILASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvnor.v\t%u0,%u1,%u1" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "V32QI")) ++ ++;; LASX ++(define_insn "vlshr<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (lshiftrt:ILASX ++ (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_uimm6_operand" "f,Uuv6"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvsrl.<lasxfmt>\t%u0,%u1,%u2 ++ xvsrli.<lasxfmt>\t%u0,%u1,%E2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++;; LASX ">>" ++(define_insn "vashr<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (ashiftrt:ILASX ++ (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_uimm6_operand" "f,Uuv6"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvsra.<lasxfmt>\t%u0,%u1,%u2 ++ xvsrai.<lasxfmt>\t%u0,%u1,%E2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++;; LASX "<<" ++(define_insn "vashl<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (ashift:ILASX ++ (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_uimm6_operand" "f,Uuv6"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvsll.<lasxfmt>\t%u0,%u1,%u2 ++ xvslli.<lasxfmt>\t%u0,%u1,%E2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "add<mode>3" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (plus:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfadd.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "sub<mode>3" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (minus:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfsub.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "mul<mode>3" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (mult:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfmul.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fmul") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "div<mode>3" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (div:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfdiv.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fma<mode>4" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (fma:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ (match_operand:FLASX 3 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfmadd.<flasxfmt>\t%u0,%u1,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fnma<mode>4" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (fma:FLASX (neg:FLASX (match_operand:FLASX 1 "register_operand" "f")) ++ (match_operand:FLASX 2 "register_operand" "f") ++ (match_operand:FLASX 3 "register_operand" "0"))) ++ "ISA_HAS_LASX" ++ "xvfnmsub.<flasxfmt>\t%u0,%u1,%u2,%u0" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "sqrt<mode>2" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (sqrt:FLASX (match_operand:FLASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfsqrt.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvadda_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (plus:ILASX (abs:ILASX (match_operand:ILASX 1 "register_operand" "f")) ++ (abs:ILASX (match_operand:ILASX 2 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvadda.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "ssadd<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (ss_plus:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvsadd.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "usadd<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (us_plus:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvsadd.<lasxfmt_u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvabsd_s_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVABSD_S)) ++ "ISA_HAS_LASX" ++ "xvabsd.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvabsd_u_<lasxfmt_u>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVABSD_U)) ++ "ISA_HAS_LASX" ++ "xvabsd.<lasxfmt_u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvavg_s_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVAVG_S)) ++ "ISA_HAS_LASX" ++ "xvavg.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvavg_u_<lasxfmt_u>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVAVG_U)) ++ "ISA_HAS_LASX" ++ "xvavg.<lasxfmt_u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvavgr_s_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVAVGR_S)) ++ "ISA_HAS_LASX" ++ "xvavgr.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvavgr_u_<lasxfmt_u>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVAVGR_U)) ++ "ISA_HAS_LASX" ++ "xvavgr.<lasxfmt_u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbitclr_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVBITCLR)) ++ "ISA_HAS_LASX" ++ "xvbitclr.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbitclri_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVBITCLRI)) ++ "ISA_HAS_LASX" ++ "xvbitclri.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbitrev_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVBITREV)) ++ "ISA_HAS_LASX" ++ "xvbitrev.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbitrevi_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVBITREVI)) ++ "ISA_HAS_LASX" ++ "xvbitrevi.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbitsel_<lasxfmt_f>" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (ior:LASX (and:LASX (not:LASX ++ (match_operand:LASX 3 "register_operand" "f")) ++ (match_operand:LASX 1 "register_operand" "f")) ++ (and:LASX (match_dup 3) ++ (match_operand:LASX 2 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvbitsel.v\t%u0,%u1,%u2,%u3" ++ (set_attr "type" "simd_bitmov") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbitseli_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (ior:V32QI (and:V32QI (not:V32QI ++ (match_operand:V32QI 1 "register_operand" "0")) ++ (match_operand:V32QI 2 "register_operand" "f")) ++ (and:V32QI (match_dup 1) ++ (match_operand:V32QI 3 "const_vector_same_val_operand" "Urv8")))) ++ "ISA_HAS_LASX" ++ "xvbitseli.b\t%u0,%u2,%B3" ++ (set_attr "type" "simd_bitmov") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvbitset_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVBITSET)) ++ "ISA_HAS_LASX" ++ "xvbitset.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbitseti_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVBITSETI)) ++ "ISA_HAS_LASX" ++ "xvbitseti.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvs<ICC:icc>_<ILASX:lasxfmt><cmpi_1>" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (ICC:ILASX ++ (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_<ICC:cmpi>imm5_operand" "f,U<ICC:cmpi>v5"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvs<ICC:icc>.<ILASX:lasxfmt><cmpi_1>\t%u0,%u1,%u2 ++ xvs<ICC:icci>.<ILASX:lasxfmt><cmpi_1>\t%u0,%u1,%E2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_expand "vec_cmp<mode><mode256_i>" ++ (set (match_operand:<VIMODE256> 0 "register_operand") ++ (match_operator 1 "" ++ (match_operand:LASX 2 "register_operand") ++ (match_operand:LASX 3 "register_operand"))) ++ "ISA_HAS_LASX" ++{ ++ bool ok = loongarch_expand_vec_cmp (operands); ++ gcc_assert (ok); ++ DONE; ++}) ++ ++(define_expand "vec_cmpu<ILASX:mode><mode256_i>" ++ (set (match_operand:<VIMODE256> 0 "register_operand") ++ (match_operator 1 "" ++ (match_operand:ILASX 2 "register_operand") ++ (match_operand:ILASX 3 "register_operand"))) ++ "ISA_HAS_LASX" ++{ ++ bool ok = loongarch_expand_vec_cmp (operands); ++ gcc_assert (ok); ++ DONE; ++}) ++ ++(define_insn "lasx_xvfclass_<flasxfmt>" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (unspec:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFCLASS)) ++ "ISA_HAS_LASX" ++ "xvfclass.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fclass") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfcmp_caf_<flasxfmt>" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (unspec:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVFCMP_CAF)) ++ "ISA_HAS_LASX" ++ "xvfcmp.caf.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfcmp_cune_<FLASX:flasxfmt>" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (unspec:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVFCMP_CUNE)) ++ "ISA_HAS_LASX" ++ "xvfcmp.cune.<FLASX:flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++ ++ ++(define_int_iterator FSC256_UNS UNSPEC_LASX_XVFCMP_SAF UNSPEC_LASX_XVFCMP_SUN ++ UNSPEC_LASX_XVFCMP_SOR UNSPEC_LASX_XVFCMP_SEQ ++ UNSPEC_LASX_XVFCMP_SNE UNSPEC_LASX_XVFCMP_SUEQ ++ UNSPEC_LASX_XVFCMP_SUNE UNSPEC_LASX_XVFCMP_SULE ++ UNSPEC_LASX_XVFCMP_SULT UNSPEC_LASX_XVFCMP_SLE ++ UNSPEC_LASX_XVFCMP_SLT) ++ ++(define_int_attr fsc256 ++ (UNSPEC_LASX_XVFCMP_SAF "saf") ++ (UNSPEC_LASX_XVFCMP_SUN "sun") ++ (UNSPEC_LASX_XVFCMP_SOR "sor") ++ (UNSPEC_LASX_XVFCMP_SEQ "seq") ++ (UNSPEC_LASX_XVFCMP_SNE "sne") ++ (UNSPEC_LASX_XVFCMP_SUEQ "sueq") ++ (UNSPEC_LASX_XVFCMP_SUNE "sune") ++ (UNSPEC_LASX_XVFCMP_SULE "sule") ++ (UNSPEC_LASX_XVFCMP_SULT "sult") ++ (UNSPEC_LASX_XVFCMP_SLE "sle") ++ (UNSPEC_LASX_XVFCMP_SLT "slt")) ++ ++(define_insn "lasx_xvfcmp_<vfcond:fcc>_<FLASX:flasxfmt>" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (vfcond:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfcmp.<vfcond:fcc>.<FLASX:flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "lasx_xvfcmp_<fsc256>_<FLASX:flasxfmt>" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (unspec:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ FSC256_UNS)) ++ "ISA_HAS_LASX" ++ "xvfcmp.<fsc256>.<FLASX:flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_mode_attr fint256 ++ (V8SF "v8si") ++ (V4DF "v4di")) ++ ++(define_mode_attr FINTCNV256 ++ (V8SF "I2S") ++ (V4DF "I2D")) ++ ++(define_mode_attr FINTCNV256_2 ++ (V8SF "S2I") ++ (V4DF "D2I")) ++ ++(define_insn "float<fint256><FLASX:mode>2" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (float:FLASX (match_operand:<VIMODE256> 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvffint.<flasxfmt>.<ilasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV256>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "floatuns<fint256><FLASX:mode>2" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (unsigned_float:FLASX ++ (match_operand:<VIMODE256> 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvffint.<flasxfmt>.<ilasxfmt_u>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV256>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_mode_attr FFQ256 ++ (V4SF "V16HI") ++ (V2DF "V8SI")) ++ ++(define_insn "lasx_xvreplgr2vr_<lasxfmt_f>" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (vec_duplicate:ILASX ++ (match_operand:<UNITMODE> 1 "reg_or_0_operand" "r,J"))) ++ "ISA_HAS_LASX" ++{ ++ if (which_alternative == 1) ++ return "xvldi.b\t%u0,0" ; ++ ++ if (!TARGET_64BIT && (<MODE>mode == V2DImode || <MODE>mode == V2DFmode)) ++ return "#"; ++ else ++ return "xvreplgr2vr.<lasxfmt>\t%u0,%z1"; ++} ++ (set_attr "type" "simd_fill") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "8")) ++ ++(define_insn "logb<mode>2" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (unspec:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFLOGB)) ++ "ISA_HAS_LASX" ++ "xvflogb.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_flog2") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "smax<mode>3" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (smax:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfmax.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfmaxa_<flasxfmt>" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (if_then_else:FLASX ++ (gt (abs:FLASX (match_operand:FLASX 1 "register_operand" "f")) ++ (abs:FLASX (match_operand:FLASX 2 "register_operand" "f"))) ++ (match_dup 1) ++ (match_dup 2))) ++ "ISA_HAS_LASX" ++ "xvfmaxa.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "smin<mode>3" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (smin:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfmin.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfmina_<flasxfmt>" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (if_then_else:FLASX ++ (lt (abs:FLASX (match_operand:FLASX 1 "register_operand" "f")) ++ (abs:FLASX (match_operand:FLASX 2 "register_operand" "f"))) ++ (match_dup 1) ++ (match_dup 2))) ++ "ISA_HAS_LASX" ++ "xvfmina.<flasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfrecip_<flasxfmt>" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (unspec:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRECIP)) ++ "ISA_HAS_LASX" ++ "xvfrecip.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfrint_<flasxfmt>" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (unspec:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINT)) ++ "ISA_HAS_LASX" ++ "xvfrint.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfrsqrt_<flasxfmt>" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (unspec:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRSQRT)) ++ "ISA_HAS_LASX" ++ "xvfrsqrt.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvftint_s_<ilasxfmt>_<flasxfmt>" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (unspec:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINT_S)) ++ "ISA_HAS_LASX" ++ "xvftint.<ilasxfmt>.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV256_2>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvftint_u_<ilasxfmt_u>_<flasxfmt>" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (unspec:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINT_U)) ++ "ISA_HAS_LASX" ++ "xvftint.<ilasxfmt_u>.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV256_2>") ++ (set_attr "mode" "<MODE>")) ++ ++ ++ ++(define_insn "fix_trunc<FLASX:mode><mode256_i>2" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (fix:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvftintrz.<ilasxfmt>.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV256_2>") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "fixuns_trunc<FLASX:mode><mode256_i>2" ++ (set (match_operand:<VIMODE256> 0 "register_operand" "=f") ++ (unsigned_fix:<VIMODE256> (match_operand:FLASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvftintrz.<ilasxfmt_u>.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV256_2>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvh<optab>w_h<u>_b<u>" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (addsub:V16HI ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))) ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))))) ++ "ISA_HAS_LASX" ++ "xvh<optab>w.h<u>.b<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvh<optab>w_w<u>_h<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (addsub:V8SI ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))))) ++ "ISA_HAS_LASX" ++ "xvh<optab>w.w<u>.h<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvh<optab>w_d<u>_w<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (addsub:V4DI ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))))) ++ "ISA_HAS_LASX" ++ "xvh<optab>w.d<u>.w<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvpackev_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_select:V32QI ++ (vec_concat:V64QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (match_operand:V32QI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 32) ++ (const_int 2) (const_int 34) ++ (const_int 4) (const_int 36) ++ (const_int 6) (const_int 38) ++ (const_int 8) (const_int 40) ++ (const_int 10) (const_int 42) ++ (const_int 12) (const_int 44) ++ (const_int 14) (const_int 46) ++ (const_int 16) (const_int 48) ++ (const_int 18) (const_int 50) ++ (const_int 20) (const_int 52) ++ (const_int 22) (const_int 54) ++ (const_int 24) (const_int 56) ++ (const_int 26) (const_int 58) ++ (const_int 28) (const_int 60) ++ (const_int 30) (const_int 62)))) ++ "ISA_HAS_LASX" ++ "xvpackev.b\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V32QI")) ++ ++ ++(define_insn "lasx_xvpackev_h" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_select:V16HI ++ (vec_concat:V32HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (match_operand:V16HI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 16) ++ (const_int 2) (const_int 18) ++ (const_int 4) (const_int 20) ++ (const_int 6) (const_int 22) ++ (const_int 8) (const_int 24) ++ (const_int 10) (const_int 26) ++ (const_int 12) (const_int 28) ++ (const_int 14) (const_int 30)))) ++ "ISA_HAS_LASX" ++ "xvpackev.h\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvpackev_w" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (vec_select:V8SI ++ (vec_concat:V16SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (match_operand:V8SI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 8) ++ (const_int 2) (const_int 10) ++ (const_int 4) (const_int 12) ++ (const_int 6) (const_int 14)))) ++ "ISA_HAS_LASX" ++ "xvpackev.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvpackev_w_f" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (vec_select:V8SF ++ (vec_concat:V16SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (match_operand:V8SF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 8) ++ (const_int 2) (const_int 10) ++ (const_int 4) (const_int 12) ++ (const_int 6) (const_int 14)))) ++ "ISA_HAS_LASX" ++ "xvpackev.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvilvh_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_select:V32QI ++ (vec_concat:V64QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (match_operand:V32QI 2 "register_operand" "f")) ++ (parallel (const_int 8) (const_int 40) ++ (const_int 9) (const_int 41) ++ (const_int 10) (const_int 42) ++ (const_int 11) (const_int 43) ++ (const_int 12) (const_int 44) ++ (const_int 13) (const_int 45) ++ (const_int 14) (const_int 46) ++ (const_int 15) (const_int 47) ++ (const_int 24) (const_int 56) ++ (const_int 25) (const_int 57) ++ (const_int 26) (const_int 58) ++ (const_int 27) (const_int 59) ++ (const_int 28) (const_int 60) ++ (const_int 29) (const_int 61) ++ (const_int 30) (const_int 62) ++ (const_int 31) (const_int 63)))) ++ "ISA_HAS_LASX" ++ "xvilvh.b\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvilvh_h" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_select:V16HI ++ (vec_concat:V32HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (match_operand:V16HI 2 "register_operand" "f")) ++ (parallel (const_int 4) (const_int 20) ++ (const_int 5) (const_int 21) ++ (const_int 6) (const_int 22) ++ (const_int 7) (const_int 23) ++ (const_int 12) (const_int 28) ++ (const_int 13) (const_int 29) ++ (const_int 14) (const_int 30) ++ (const_int 15) (const_int 31)))) ++ "ISA_HAS_LASX" ++ "xvilvh.h\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16HI")) ++ ++(define_mode_attr xvilvh_suffix ++ (V8SI "") (V8SF "_f") ++ (V4DI "") (V4DF "_f")) ++ ++(define_insn "lasx_xvilvh_w<xvilvh_suffix>" ++ (set (match_operand:LASX_W 0 "register_operand" "=f") ++ (vec_select:LASX_W ++ (vec_concat:<VEMODE256> ++ (match_operand:LASX_W 1 "register_operand" "f") ++ (match_operand:LASX_W 2 "register_operand" "f")) ++ (parallel (const_int 2) (const_int 10) ++ (const_int 3) (const_int 11) ++ (const_int 6) (const_int 14) ++ (const_int 7) (const_int 15)))) ++ "ISA_HAS_LASX" ++ "xvilvh.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvilvh_d<xvilvh_suffix>" ++ (set (match_operand:LASX_D 0 "register_operand" "=f") ++ (vec_select:LASX_D ++ (vec_concat:<VEMODE256> ++ (match_operand:LASX_D 1 "register_operand" "f") ++ (match_operand:LASX_D 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 5) ++ (const_int 3) (const_int 7)))) ++ "ISA_HAS_LASX" ++ "xvilvh.d\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvpackod_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_select:V32QI ++ (vec_concat:V64QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (match_operand:V32QI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 33) ++ (const_int 3) (const_int 35) ++ (const_int 5) (const_int 37) ++ (const_int 7) (const_int 39) ++ (const_int 9) (const_int 41) ++ (const_int 11) (const_int 43) ++ (const_int 13) (const_int 45) ++ (const_int 15) (const_int 47) ++ (const_int 17) (const_int 49) ++ (const_int 19) (const_int 51) ++ (const_int 21) (const_int 53) ++ (const_int 23) (const_int 55) ++ (const_int 25) (const_int 57) ++ (const_int 27) (const_int 59) ++ (const_int 29) (const_int 61) ++ (const_int 31) (const_int 63)))) ++ "ISA_HAS_LASX" ++ "xvpackod.b\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V32QI")) ++ ++ ++(define_insn "lasx_xvpackod_h" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_select:V16HI ++ (vec_concat:V32HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (match_operand:V16HI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 17) ++ (const_int 3) (const_int 19) ++ (const_int 5) (const_int 21) ++ (const_int 7) (const_int 23) ++ (const_int 9) (const_int 25) ++ (const_int 11) (const_int 27) ++ (const_int 13) (const_int 29) ++ (const_int 15) (const_int 31)))) ++ "ISA_HAS_LASX" ++ "xvpackod.h\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16HI")) ++ ++ ++(define_insn "lasx_xvpackod_w" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (vec_select:V8SI ++ (vec_concat:V16SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (match_operand:V8SI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 9) ++ (const_int 3) (const_int 11) ++ (const_int 5) (const_int 13) ++ (const_int 7) (const_int 15)))) ++ "ISA_HAS_LASX" ++ "xvpackod.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SI")) ++ ++ ++(define_insn "lasx_xvpackod_w_f" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (vec_select:V8SF ++ (vec_concat:V16SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (match_operand:V8SF 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 9) ++ (const_int 3) (const_int 11) ++ (const_int 5) (const_int 13) ++ (const_int 7) (const_int 15)))) ++ "ISA_HAS_LASX" ++ "xvpackod.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvilvl_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_select:V32QI ++ (vec_concat:V64QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (match_operand:V32QI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 32) ++ (const_int 1) (const_int 33) ++ (const_int 2) (const_int 34) ++ (const_int 3) (const_int 35) ++ (const_int 4) (const_int 36) ++ (const_int 5) (const_int 37) ++ (const_int 6) (const_int 38) ++ (const_int 7) (const_int 39) ++ (const_int 16) (const_int 48) ++ (const_int 17) (const_int 49) ++ (const_int 18) (const_int 50) ++ (const_int 19) (const_int 51) ++ (const_int 20) (const_int 52) ++ (const_int 21) (const_int 53) ++ (const_int 22) (const_int 54) ++ (const_int 23) (const_int 55)))) ++ "ISA_HAS_LASX" ++ "xvilvl.b\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvilvl_h" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_select:V16HI ++ (vec_concat:V32HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (match_operand:V16HI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 16) ++ (const_int 1) (const_int 17) ++ (const_int 2) (const_int 18) ++ (const_int 3) (const_int 19) ++ (const_int 8) (const_int 24) ++ (const_int 9) (const_int 25) ++ (const_int 10) (const_int 26) ++ (const_int 11) (const_int 27)))) ++ "ISA_HAS_LASX" ++ "xvilvl.h\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvilvl_w" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (vec_select:V8SI ++ (vec_concat:V16SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (match_operand:V8SI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 8) ++ (const_int 1) (const_int 9) ++ (const_int 4) (const_int 12) ++ (const_int 5) (const_int 13)))) ++ "ISA_HAS_LASX" ++ "xvilvl.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvilvl_w_f" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (vec_select:V8SF ++ (vec_concat:V16SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (match_operand:V8SF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 8) ++ (const_int 1) (const_int 9) ++ (const_int 4) (const_int 12) ++ (const_int 5) (const_int 13)))) ++ "ISA_HAS_LASX" ++ "xvilvl.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvilvl_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (vec_select:V4DI ++ (vec_concat:V8DI ++ (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 4) ++ (const_int 2) (const_int 6)))) ++ "ISA_HAS_LASX" ++ "xvilvl.d\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvilvl_d_f" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (vec_select:V4DF ++ (vec_concat:V8DF ++ (match_operand:V4DF 1 "register_operand" "f") ++ (match_operand:V4DF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 4) ++ (const_int 2) (const_int 6)))) ++ "ISA_HAS_LASX" ++ "xvilvl.d\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "smax<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (smax:ILASX (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_simm5_operand" "f,Usv5"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvmax.<lasxfmt>\t%u0,%u1,%u2 ++ xvmaxi.<lasxfmt>\t%u0,%u1,%E2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "umax<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (umax:ILASX (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_uimm5_operand" "f,Uuv5"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvmax.<lasxfmt_u>\t%u0,%u1,%u2 ++ xvmaxi.<lasxfmt_u>\t%u0,%u1,%B2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "smin<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (smin:ILASX (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_simm5_operand" "f,Usv5"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvmin.<lasxfmt>\t%u0,%u1,%u2 ++ xvmini.<lasxfmt>\t%u0,%u1,%E2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "umin<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (umin:ILASX (match_operand:ILASX 1 "register_operand" "f,f") ++ (match_operand:ILASX 2 "reg_or_vector_same_uimm5_operand" "f,Uuv5"))) ++ "ISA_HAS_LASX" ++ "@ ++ xvmin.<lasxfmt_u>\t%u0,%u1,%u2 ++ xvmini.<lasxfmt_u>\t%u0,%u1,%B2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvclo_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (clz:ILASX (not:ILASX (match_operand:ILASX 1 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvclo.<lasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "clz<mode>2" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (clz:ILASX (match_operand:ILASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvclz.<lasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvnor_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f,f") ++ (and:ILASX (not:ILASX (match_operand:ILASX 1 "register_operand" "f,f")) ++ (not:ILASX (match_operand:ILASX 2 "reg_or_vector_same_val_operand" "f,Urv8")))) ++ "ISA_HAS_LASX" ++ "@ ++ xvnor.v\t%u0,%u1,%u2 ++ xvnori.b\t%u0,%u1,%B2" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvpickev_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_select:V32QI ++ (vec_concat:V64QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (match_operand:V32QI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 32) (const_int 34) ++ (const_int 36) (const_int 38) ++ (const_int 40) (const_int 42) ++ (const_int 44) (const_int 46) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30) ++ (const_int 48) (const_int 50) ++ (const_int 52) (const_int 54) ++ (const_int 56) (const_int 58) ++ (const_int 60) (const_int 62)))) ++ "ISA_HAS_LASX" ++ "xvpickev.b\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvpickev_h" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_select:V16HI ++ (vec_concat:V32HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (match_operand:V16HI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))) ++ "ISA_HAS_LASX" ++ "xvpickev.h\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvpickev_w" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (vec_select:V8SI ++ (vec_concat:V16SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (match_operand:V8SI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 8) (const_int 10) ++ (const_int 4) (const_int 6) ++ (const_int 12) (const_int 14)))) ++ "ISA_HAS_LASX" ++ "xvpickev.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvpickev_w_f" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (vec_select:V8SF ++ (vec_concat:V16SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (match_operand:V8SF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 8) (const_int 10) ++ (const_int 4) (const_int 6) ++ (const_int 12) (const_int 14)))) ++ "ISA_HAS_LASX" ++ "xvpickev.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvpickod_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_select:V32QI ++ (vec_concat:V64QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (match_operand:V32QI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 33) (const_int 35) ++ (const_int 37) (const_int 39) ++ (const_int 41) (const_int 43) ++ (const_int 45) (const_int 47) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31) ++ (const_int 49) (const_int 51) ++ (const_int 53) (const_int 55) ++ (const_int 57) (const_int 59) ++ (const_int 61) (const_int 63)))) ++ "ISA_HAS_LASX" ++ "xvpickod.b\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvpickod_h" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_select:V16HI ++ (vec_concat:V32HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (match_operand:V16HI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))) ++ "ISA_HAS_LASX" ++ "xvpickod.h\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvpickod_w" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (vec_select:V8SI ++ (vec_concat:V16SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (match_operand:V8SI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 9) (const_int 11) ++ (const_int 5) (const_int 7) ++ (const_int 13) (const_int 15)))) ++ "ISA_HAS_LASX" ++ "xvpickod.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvpickod_w_f" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (vec_select:V8SF ++ (vec_concat:V16SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (match_operand:V8SF 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 9) (const_int 11) ++ (const_int 5) (const_int 7) ++ (const_int 13) (const_int 15)))) ++ "ISA_HAS_LASX" ++ "xvpickod.w\t%u0,%u2,%u1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "popcount<mode>2" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (popcount:ILASX (match_operand:ILASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvpcnt.<lasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_pcnt") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "lasx_xvsat_s_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVSAT_S)) ++ "ISA_HAS_LASX" ++ "xvsat.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_sat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsat_u_<lasxfmt_u>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVSAT_U)) ++ "ISA_HAS_LASX" ++ "xvsat.<lasxfmt_u>\t%u0,%u1,%2" ++ (set_attr "type" "simd_sat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvshuf4i_<lasxfmt_f>" ++ (set (match_operand:LASX_WHB_W 0 "register_operand" "=f") ++ (unspec:LASX_WHB_W (match_operand:LASX_WHB_W 1 "register_operand" "f") ++ (match_operand 2 "const_uimm8_operand") ++ UNSPEC_LASX_XVSHUF4I)) ++ "ISA_HAS_LASX" ++ "xvshuf4i.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvshuf4i_<lasxfmt_f>_1" ++ (set (match_operand:LASX_W 0 "register_operand" "=f") ++ (vec_select:LASX_W ++ (match_operand:LASX_W 1 "nonimmediate_operand" "f") ++ (parallel (match_operand 2 "const_0_to_3_operand") ++ (match_operand 3 "const_0_to_3_operand") ++ (match_operand 4 "const_0_to_3_operand") ++ (match_operand 5 "const_0_to_3_operand") ++ (match_operand 6 "const_4_to_7_operand") ++ (match_operand 7 "const_4_to_7_operand") ++ (match_operand 8 "const_4_to_7_operand") ++ (match_operand 9 "const_4_to_7_operand")))) ++ "ISA_HAS_LASX ++ && INTVAL (operands2) + 4 == INTVAL (operands6) ++ && INTVAL (operands3) + 4 == INTVAL (operands7) ++ && INTVAL (operands4) + 4 == INTVAL (operands8) ++ && INTVAL (operands5) + 4 == INTVAL (operands9)" ++{ ++ int mask = 0; ++ mask |= INTVAL (operands2) << 0; ++ mask |= INTVAL (operands3) << 2; ++ mask |= INTVAL (operands4) << 4; ++ mask |= INTVAL (operands5) << 6; ++ operands2 = GEN_INT (mask); ++ ++ return "xvshuf4i.w\t%u0,%u1,%2"; ++} ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrar_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVSRAR)) ++ "ISA_HAS_LASX" ++ "xvsrar.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrari_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVSRARI)) ++ "ISA_HAS_LASX" ++ "xvsrari.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrlr_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVSRLR)) ++ "ISA_HAS_LASX" ++ "xvsrlr.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrlri_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVSRLRI)) ++ "ISA_HAS_LASX" ++ "xvsrlri.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssub_s_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (ss_minus:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvssub.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssub_u_<lasxfmt_u>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (us_minus:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvssub.<lasxfmt_u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvshuf_<lasxfmt_f>" ++ (set (match_operand:LASX_DWH 0 "register_operand" "=f") ++ (unspec:LASX_DWH (match_operand:LASX_DWH 1 "register_operand" "0") ++ (match_operand:LASX_DWH 2 "register_operand" "f") ++ (match_operand:LASX_DWH 3 "register_operand" "f") ++ UNSPEC_LASX_XVSHUF)) ++ "ISA_HAS_LASX" ++ "xvshuf.<lasxfmt>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_sld") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvshuf_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (unspec:V32QI (match_operand:V32QI 1 "register_operand" "f") ++ (match_operand:V32QI 2 "register_operand" "f") ++ (match_operand:V32QI 3 "register_operand" "f") ++ UNSPEC_LASX_XVSHUF_B)) ++ "ISA_HAS_LASX" ++ "xvshuf.b\t%u0,%u1,%u2,%u3" ++ (set_attr "type" "simd_sld") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvreplve0_<lasxfmt_f>" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (vec_duplicate:LASX ++ (vec_select:<UNITMODE> ++ (match_operand:LASX 1 "register_operand" "f") ++ (parallel (const_int 0))))) ++ "ISA_HAS_LASX" ++ "xvreplve0.<lasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvrepl128vei_b_internal" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (vec_duplicate:V32QI ++ (vec_select:V32QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_uimm4_operand" "") ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_operand 3 "const_16_to_31_operand" "") ++ (match_dup 3) (match_dup 3) (match_dup 3) ++ (match_dup 3) (match_dup 3) (match_dup 3) ++ (match_dup 3) (match_dup 3) (match_dup 3) ++ (match_dup 3) (match_dup 3) (match_dup 3) ++ (match_dup 3) (match_dup 3) (match_dup 3))))) ++ "ISA_HAS_LASX && ((INTVAL (operands3) - INTVAL (operands2)) == 16)" ++ "xvrepl128vei.b\t%u0,%u1,%2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvrepl128vei_h_internal" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (vec_duplicate:V16HI ++ (vec_select:V16HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_uimm3_operand" "") ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_dup 2) ++ (match_operand 3 "const_8_to_15_operand" "") ++ (match_dup 3) (match_dup 3) (match_dup 3) ++ (match_dup 3) (match_dup 3) (match_dup 3) ++ (match_dup 3))))) ++ "ISA_HAS_LASX && ((INTVAL (operands3) - INTVAL (operands2)) == 8)" ++ "xvrepl128vei.h\t%u0,%u1,%2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvrepl128vei_w_internal" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (vec_duplicate:V8SI ++ (vec_select:V8SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_0_to_3_operand" "") ++ (match_dup 2) (match_dup 2) (match_dup 2) ++ (match_operand 3 "const_4_to_7_operand" "") ++ (match_dup 3) (match_dup 3) (match_dup 3))))) ++ "ISA_HAS_LASX && ((INTVAL (operands3) - INTVAL (operands2)) == 4)" ++ "xvrepl128vei.w\t%u0,%u1,%2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvrepl128vei_d_internal" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (vec_duplicate:V4DI ++ (vec_select:V4DI ++ (match_operand:V4DI 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_0_or_1_operand" "") ++ (match_dup 2) ++ (match_operand 3 "const_2_or_3_operand" "") ++ (match_dup 3))))) ++ "ISA_HAS_LASX && ((INTVAL (operands3) - INTVAL (operands2)) == 2)" ++ "xvrepl128vei.d\t%u0,%u1,%2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvrepl128vei_<lasxfmt_f>" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (unspec:LASX (match_operand:LASX 1 "register_operand" "f") ++ (match_operand 2 "const_<indeximm_lo>_operand" "") ++ UNSPEC_LASX_XVREPL128VEI)) ++ "ISA_HAS_LASX" ++ "xvrepl128vei.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvreplve0_<lasxfmt_f>_scalar" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (vec_duplicate:FLASX ++ (match_operand:<UNITMODE> 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvreplve0.<lasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvreplve0_q" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (unspec:V32QI (match_operand:V32QI 1 "register_operand" "f") ++ UNSPEC_LASX_XVREPLVE0_Q)) ++ "ISA_HAS_LASX" ++ "xvreplve0.q\t%u0,%u1" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvfcvt_h_s" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (unspec:V16HI (match_operand:V8SF 1 "register_operand" "f") ++ (match_operand:V8SF 2 "register_operand" "f") ++ UNSPEC_LASX_XVFCVT)) ++ "ISA_HAS_LASX" ++ "xvfcvt.h.s\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvfcvt_s_d" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V4DF 1 "register_operand" "f") ++ (match_operand:V4DF 2 "register_operand" "f") ++ UNSPEC_LASX_XVFCVT)) ++ "ISA_HAS_LASX" ++ "xvfcvt.s.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "vec_pack_trunc_v4df" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (vec_concat:V8SF ++ (float_truncate:V4SF (match_operand:V4DF 1 "register_operand" "f")) ++ (float_truncate:V4SF (match_operand:V4DF 2 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvfcvt.s.d\t%u0,%u2,%u1\n\txvpermi.d\t%u0,%u0,0xd8" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V8SF") ++ (set_attr "length" "8")) ++ ++;; Define for builtin function. ++(define_insn "lasx_xvfcvth_s_h" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V16HI 1 "register_operand" "f") ++ UNSPEC_LASX_XVFCVTH)) ++ "ISA_HAS_LASX" ++ "xvfcvth.s.h\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V8SF")) ++ ++;; Define for builtin function. ++(define_insn "lasx_xvfcvth_d_s" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (float_extend:V4DF ++ (vec_select:V4SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (parallel (const_int 2) (const_int 3) ++ (const_int 6) (const_int 7))))) ++ "ISA_HAS_LASX" ++ "xvfcvth.d.s\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DF") ++ (set_attr "length" "12")) ++ ++;; Define for gen insn. ++(define_insn "lasx_xvfcvth_d_insn" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (float_extend:V4DF ++ (vec_select:V4SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (parallel (const_int 4) (const_int 5) ++ (const_int 6) (const_int 7))))) ++ "ISA_HAS_LASX" ++ "xvpermi.d\t%u0,%u1,0xfa\n\txvfcvtl.d.s\t%u0,%u0" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DF") ++ (set_attr "length" "12")) ++ ++;; Define for builtin function. ++(define_insn "lasx_xvfcvtl_s_h" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V16HI 1 "register_operand" "f") ++ UNSPEC_LASX_XVFCVTL)) ++ "ISA_HAS_LASX" ++ "xvfcvtl.s.h\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V8SF")) ++ ++;; Define for builtin function. ++(define_insn "lasx_xvfcvtl_d_s" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (float_extend:V4DF ++ (vec_select:V4SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 4) (const_int 5))))) ++ "ISA_HAS_LASX" ++ "xvfcvtl.d.s\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DF") ++ (set_attr "length" "8")) ++ ++;; Define for gen insn. ++(define_insn "lasx_xvfcvtl_d_insn" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (float_extend:V4DF ++ (vec_select:V4SF ++ (match_operand:V8SF 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 2) (const_int 3))))) ++ "ISA_HAS_LASX" ++ "xvpermi.d\t%u0,%u1,0x50\n\txvfcvtl.d.s\t%u0,%u0" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DF") ++ (set_attr "length" "8")) ++ ++(define_code_attr lasxbr ++ (eq "xbz") ++ (ne "xbnz")) ++ ++(define_code_attr lasxeq_v ++ (eq "eqz") ++ (ne "nez")) ++ ++(define_code_attr lasxne_v ++ (eq "nez") ++ (ne "eqz")) ++ ++(define_code_attr lasxeq ++ (eq "anyeqz") ++ (ne "allnez")) ++ ++(define_code_attr lasxne ++ (eq "allnez") ++ (ne "anyeqz")) ++ ++(define_insn "lasx_<lasxbr>_<lasxfmt_f>" ++ (set (pc) ++ (if_then_else ++ (equality_op ++ (unspec:SI (match_operand:LASX 1 "register_operand" "f") ++ UNSPEC_LASX_BRANCH) ++ (match_operand:SI 2 "const_0_operand")) ++ (label_ref (match_operand 0)) ++ (pc))) ++ (clobber (match_scratch:FCC 3 "=z")) ++ "ISA_HAS_LASX" ++{ ++ return loongarch_output_conditional_branch (insn, operands, ++ "xvset<lasxeq>.<lasxfmt>\t%Z3%u1\n\tbcnez\t%Z3%0", ++ "xvset<lasxne>.<lasxfmt>\t%z3%u1\n\tbcnez\t%Z3%0"); ++} ++ (set_attr "type" "simd_branch") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_<lasxbr>_v_<lasxfmt_f>" ++ (set (pc) ++ (if_then_else ++ (equality_op ++ (unspec:SI (match_operand:LASX 1 "register_operand" "f") ++ UNSPEC_LASX_BRANCH_V) ++ (match_operand:SI 2 "const_0_operand")) ++ (label_ref (match_operand 0)) ++ (pc))) ++ (clobber (match_scratch:FCC 3 "=z")) ++ "ISA_HAS_LASX" ++{ ++ return loongarch_output_conditional_branch (insn, operands, ++ "xvset<lasxeq_v>.v\t%Z3%u1\n\tbcnez\t%Z3%0", ++ "xvset<lasxne_v>.v\t%Z3%u1\n\tbcnez\t%Z3%0"); ++} ++ (set_attr "type" "simd_branch") ++ (set_attr "mode" "<MODE>")) ++ ++;; loongson-asx. ++(define_insn "lasx_vext2xv_h<u>_b<u>" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 2) (const_int 3) ++ (const_int 4) (const_int 5) ++ (const_int 6) (const_int 7) ++ (const_int 8) (const_int 9) ++ (const_int 10) (const_int 11) ++ (const_int 12) (const_int 13) ++ (const_int 14) (const_int 15))))) ++ "ISA_HAS_LASX" ++ "vext2xv.h<u>.b<u>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_vext2xv_w<u>_h<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 2) (const_int 3) ++ (const_int 4) (const_int 5) ++ (const_int 6) (const_int 7))))) ++ "ISA_HAS_LASX" ++ "vext2xv.w<u>.h<u>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_vext2xv_d<u>_w<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 2) (const_int 3))))) ++ "ISA_HAS_LASX" ++ "vext2xv.d<u>.w<u>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_vext2xv_w<u>_b<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (any_extend:V8SI ++ (vec_select:V8QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 2) (const_int 3) ++ (const_int 4) (const_int 5) ++ (const_int 6) (const_int 7))))) ++ "ISA_HAS_LASX" ++ "vext2xv.w<u>.b<u>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_vext2xv_d<u>_h<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (any_extend:V4DI ++ (vec_select:V4HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 2) (const_int 3))))) ++ "ISA_HAS_LASX" ++ "vext2xv.d<u>.h<u>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_vext2xv_d<u>_b<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (any_extend:V4DI ++ (vec_select:V4QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1) ++ (const_int 2) (const_int 3))))) ++ "ISA_HAS_LASX" ++ "vext2xv.d<u>.b<u>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DI")) ++ ++;; Extend loongson-sx to loongson-asx. ++(define_insn "xvandn<mode>3" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (and:LASX (not:LASX (match_operand:LASX 1 "register_operand" "f")) ++ (match_operand:LASX 2 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvandn.v\t%u0,%u1,%u2" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "abs<mode>2" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (abs:ILASX (match_operand:ILASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvsigncov.<lasxfmt>\t%u0,%u1,%u1" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "neg<mode>2" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (neg:ILASX (match_operand:ILASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvneg.<lasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvmuh_s_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVMUH_S)) ++ "ISA_HAS_LASX" ++ "xvmuh.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvmuh_u_<lasxfmt_u>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVMUH_U)) ++ "ISA_HAS_LASX" ++ "xvmuh.<lasxfmt_u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsllwil_s_<dlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VDMODE256> 0 "register_operand" "=f") ++ (unspec:<VDMODE256> (match_operand:ILASX_WHB 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVSLLWIL_S)) ++ "ISA_HAS_LASX" ++ "xvsllwil.<dlasxfmt>.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsllwil_u_<dlasxfmt_u>_<lasxfmt_u>" ++ (set (match_operand:<VDMODE256> 0 "register_operand" "=f") ++ (unspec:<VDMODE256> (match_operand:ILASX_WHB 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" "") ++ UNSPEC_LASX_XVSLLWIL_U)) ++ "ISA_HAS_LASX" ++ "xvsllwil.<dlasxfmt_u>.<lasxfmt_u>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsran_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSRAN)) ++ "ISA_HAS_LASX" ++ "xvsran.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssran_s_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRAN_S)) ++ "ISA_HAS_LASX" ++ "xvssran.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssran_u_<hlasxfmt_u>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRAN_U)) ++ "ISA_HAS_LASX" ++ "xvssran.<hlasxfmt_u>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrarn_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSRARN)) ++ "ISA_HAS_LASX" ++ "xvsrarn.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrarn_s_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRARN_S)) ++ "ISA_HAS_LASX" ++ "xvssrarn.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrarn_u_<hlasxfmt_u>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRARN_U)) ++ "ISA_HAS_LASX" ++ "xvssrarn.<hlasxfmt_u>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrln_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSRLN)) ++ "ISA_HAS_LASX" ++ "xvsrln.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrln_u_<hlasxfmt_u>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRLN_U)) ++ "ISA_HAS_LASX" ++ "xvssrln.<hlasxfmt_u>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrlrn_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSRLRN)) ++ "ISA_HAS_LASX" ++ "xvsrlrn.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrlrn_u_<hlasxfmt_u>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRLRN_U)) ++ "ISA_HAS_LASX" ++ "xvssrlrn.<hlasxfmt_u>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfrstpi_<lasxfmt>" ++ (set (match_operand:ILASX_HB 0 "register_operand" "=f") ++ (unspec:ILASX_HB (match_operand:ILASX_HB 1 "register_operand" "0") ++ (match_operand:ILASX_HB 2 "register_operand" "f") ++ (match_operand 3 "const_uimm5_operand" "") ++ UNSPEC_LASX_XVFRSTPI)) ++ "ISA_HAS_LASX" ++ "xvfrstpi.<lasxfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvfrstp_<lasxfmt>" ++ (set (match_operand:ILASX_HB 0 "register_operand" "=f") ++ (unspec:ILASX_HB (match_operand:ILASX_HB 1 "register_operand" "0") ++ (match_operand:ILASX_HB 2 "register_operand" "f") ++ (match_operand:ILASX_HB 3 "register_operand" "f") ++ UNSPEC_LASX_XVFRSTP)) ++ "ISA_HAS_LASX" ++ "xvfrstp.<lasxfmt>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvshuf4i_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "0") ++ (match_operand:V4DI 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand") ++ UNSPEC_LASX_XVSHUF4I)) ++ "ISA_HAS_LASX" ++ "xvshuf4i.d\t%u0,%u2,%3" ++ (set_attr "type" "simd_sld") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvbsrl_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_uimm5_operand" "") ++ UNSPEC_LASX_XVBSRL_V)) ++ "ISA_HAS_LASX" ++ "xvbsrl.v\t%u0,%u1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvbsll_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_uimm5_operand" "") ++ UNSPEC_LASX_XVBSLL_V)) ++ "ISA_HAS_LASX" ++ "xvbsll.v\t%u0,%u1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvextrins_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVEXTRINS)) ++ "ISA_HAS_LASX" ++ "xvextrins.<lasxfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvmskltz_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVMSKLTZ)) ++ "ISA_HAS_LASX" ++ "xvmskltz.<lasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsigncov_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVSIGNCOV)) ++ "ISA_HAS_LASX" ++ "xvsigncov.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_expand "copysign<mode>3" ++ (set (match_dup 4) ++ (and:FLASX ++ (not:FLASX (match_dup 3)) ++ (match_operand:FLASX 1 "register_operand"))) ++ (set (match_dup 5) ++ (and:FLASX (match_dup 3) ++ (match_operand:FLASX 2 "register_operand"))) ++ (set (match_operand:FLASX 0 "register_operand") ++ (ior:FLASX (match_dup 4) (match_dup 5))) ++ "ISA_HAS_LASX" ++{ ++ operands3 = loongarch_build_signbit_mask (<MODE>mode, 1, 0); ++ ++ operands4 = gen_reg_rtx (<MODE>mode); ++ operands5 = gen_reg_rtx (<MODE>mode); ++}) ++ ++ ++(define_insn "absv4df2" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (abs:V4DF (match_operand:V4DF 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvbitclri.d\t%u0,%u1,63" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "absv8sf2" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (abs:V8SF (match_operand:V8SF 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvbitclri.w\t%u0,%u1,31" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "negv4df2" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (neg:V4DF (match_operand:V4DF 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvbitrevi.d\t%u0,%u1,63" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "negv8sf2" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (neg:V8SF (match_operand:V8SF 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvbitrevi.w\t%u0,%u1,31" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "xvfmadd<mode>4" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (fma:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ (match_operand:FLASX 3 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvfmadd.<flasxfmt>\t%u0,%u1,$u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fms<mode>4" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (fma:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ (neg:FLASX (match_operand:FLASX 3 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvfmsub.<flasxfmt>\t%u0,%u1,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "xvfnmsub<mode>4_nmsub4" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (neg:FLASX ++ (fma:FLASX ++ (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ (neg:FLASX (match_operand:FLASX 3 "register_operand" "f"))))) ++ "ISA_HAS_LASX" ++ "xvfnmsub.<flasxfmt>\t%u0,%u1,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "xvfnmadd<mode>4_nmadd4" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (neg:FLASX ++ (fma:FLASX ++ (match_operand:FLASX 1 "register_operand" "f") ++ (match_operand:FLASX 2 "register_operand" "f") ++ (match_operand:FLASX 3 "register_operand" "f")))) ++ "ISA_HAS_LASX" ++ "xvfnmadd.<flasxfmt>\t%u0,%u1,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvftintrne_w_s" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRNE_W_S)) ++ "ISA_HAS_LASX" ++ "xvftintrne.w.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrne_l_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRNE_L_D)) ++ "ISA_HAS_LASX" ++ "xvftintrne.l.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvftintrp_w_s" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRP_W_S)) ++ "ISA_HAS_LASX" ++ "xvftintrp.w.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrp_l_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRP_L_D)) ++ "ISA_HAS_LASX" ++ "xvftintrp.l.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvftintrm_w_s" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRM_W_S)) ++ "ISA_HAS_LASX" ++ "xvftintrm.w.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrm_l_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRM_L_D)) ++ "ISA_HAS_LASX" ++ "xvftintrm.l.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvftint_w_d" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V4DF 1 "register_operand" "f") ++ (match_operand:V4DF 2 "register_operand" "f") ++ UNSPEC_LASX_XVFTINT_W_D)) ++ "ISA_HAS_LASX" ++ "xvftint.w.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvffint_s_l" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVFFINT_S_L)) ++ "ISA_HAS_LASX" ++ "xvffint.s.l\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvftintrz_w_d" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V4DF 1 "register_operand" "f") ++ (match_operand:V4DF 2 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRZ_W_D)) ++ "ISA_HAS_LASX" ++ "xvftintrz.w.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvftintrp_w_d" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V4DF 1 "register_operand" "f") ++ (match_operand:V4DF 2 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRP_W_D)) ++ "ISA_HAS_LASX" ++ "xvftintrp.w.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvftintrm_w_d" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V4DF 1 "register_operand" "f") ++ (match_operand:V4DF 2 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRM_W_D)) ++ "ISA_HAS_LASX" ++ "xvftintrm.w.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvftintrne_w_d" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (unspec:V8SI (match_operand:V4DF 1 "register_operand" "f") ++ (match_operand:V4DF 2 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRNE_W_D)) ++ "ISA_HAS_LASX" ++ "xvftintrne.w.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvftinth_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTH_L_S)) ++ "ISA_HAS_LASX" ++ "xvftinth.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintl_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTL_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintl.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvffinth_d_w" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (unspec:V4DF (match_operand:V8SI 1 "register_operand" "f") ++ UNSPEC_LASX_XVFFINTH_D_W)) ++ "ISA_HAS_LASX" ++ "xvffinth.d.w\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvffintl_d_w" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (unspec:V4DF (match_operand:V8SI 1 "register_operand" "f") ++ UNSPEC_LASX_XVFFINTL_D_W)) ++ "ISA_HAS_LASX" ++ "xvffintl.d.w\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvftintrzh_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRZH_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrzh.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrzl_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRZL_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrzl.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lasx_xvftintrph_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRPH_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrph.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lasx_xvftintrpl_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRPL_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrpl.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrmh_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRMH_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrmh.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrml_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRML_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrml.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrneh_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRNEH_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrneh.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvftintrnel_l_s" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFTINTRNEL_L_S)) ++ "ISA_HAS_LASX" ++ "xvftintrnel.l.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvfrintrne_s" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRNE_S)) ++ "ISA_HAS_LASX" ++ "xvfrintrne.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvfrintrne_d" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (unspec:V4DF (match_operand:V4DF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRNE_D)) ++ "ISA_HAS_LASX" ++ "xvfrintrne.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvfrintrz_s" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRZ_S)) ++ "ISA_HAS_LASX" ++ "xvfrintrz.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvfrintrz_d" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (unspec:V4DF (match_operand:V4DF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRZ_D)) ++ "ISA_HAS_LASX" ++ "xvfrintrz.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvfrintrp_s" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRP_S)) ++ "ISA_HAS_LASX" ++ "xvfrintrp.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvfrintrp_d" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (unspec:V4DF (match_operand:V4DF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRP_D)) ++ "ISA_HAS_LASX" ++ "xvfrintrp.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++(define_insn "lasx_xvfrintrm_s" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V8SF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRM_S)) ++ "ISA_HAS_LASX" ++ "xvfrintrm.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "lasx_xvfrintrm_d" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (unspec:V4DF (match_operand:V4DF 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINTRM_D)) ++ "ISA_HAS_LASX" ++ "xvfrintrm.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++;; Vector versions of the floating-point frint patterns. ++;; Expands to btrunc, ceil, floor, rint. ++(define_insn "<FRINT256_S:frint256_pattern_s>v8sf2" ++ (set (match_operand:V8SF 0 "register_operand" "=f") ++ (unspec:V8SF (match_operand:V8SF 1 "register_operand" "f") ++ FRINT256_S)) ++ "ISA_HAS_LASX" ++ "xvfrint<FRINT256_S:frint256_suffix>.s\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V8SF")) ++ ++(define_insn "<FRINT256_D:frint256_pattern_d>v4df2" ++ (set (match_operand:V4DF 0 "register_operand" "=f") ++ (unspec:V4DF (match_operand:V4DF 1 "register_operand" "f") ++ FRINT256_D)) ++ "ISA_HAS_LASX" ++ "xvfrint<FRINT256_D:frint256_suffix>.d\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4DF")) ++ ++;; Expands to round. ++(define_insn "round<mode>2" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (unspec:FLASX (match_operand:FLASX 1 "register_operand" "f") ++ UNSPEC_LASX_XVFRINT)) ++ "ISA_HAS_LASX" ++ "xvfrint.<flasxfmt>\t%u0,%u1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++;; Offset load and broadcast ++(define_expand "lasx_xvldrepl_<lasxfmt_f>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand 2 "aq12<lasxfmt>_operand") ++ (match_operand 1 "pmode_register_operand") ++ "ISA_HAS_LASX" ++{ ++ emit_insn (gen_lasx_xvldrepl_<lasxfmt_f>_insn ++ (operands0, operands1, operands2)); ++ DONE; ++}) ++ ++(define_insn "lasx_xvldrepl_<lasxfmt_f>_insn" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (vec_duplicate:LASX ++ (mem:<UNITMODE> (plus:DI (match_operand:DI 1 "register_operand" "r") ++ (match_operand 2 "aq12<lasxfmt>_operand"))))) ++ "ISA_HAS_LASX" ++{ ++ return "xvldrepl.<lasxfmt>\t%u0,%1,%2"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++;; Offset is "0" ++(define_insn "lasx_xvldrepl_<lasxfmt_f>_insn_0" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (vec_duplicate:LASX ++ (mem:<UNITMODE> (match_operand:DI 1 "register_operand" "r")))) ++ "ISA_HAS_LASX" ++{ ++ return "xvldrepl.<lasxfmt>\t%u0,%1,0"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++;;XVADDWEV.H.B XVSUBWEV.H.B XVMULWEV.H.B ++;;XVADDWEV.H.BU XVSUBWEV.H.BU XVMULWEV.H.BU ++(define_insn "lasx_xv<optab>wev_h_b<u>" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (addsubmul:V16HI ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))) ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wev.h.b<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V16HI")) ++ ++;;XVADDWEV.W.H XVSUBWEV.W.H XVMULWEV.W.H ++;;XVADDWEV.W.HU XVSUBWEV.W.HU XVMULWEV.W.HU ++(define_insn "lasx_xv<optab>wev_w_h<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (addsubmul:V8SI ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wev.w.h<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8SI")) ++ ++;;XVADDWEV.D.W XVSUBWEV.D.W XVMULWEV.D.W ++;;XVADDWEV.D.WU XVSUBWEV.D.WU XVMULWEV.D.WU ++(define_insn "lasx_xv<optab>wev_d_w<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (addsubmul:V4DI ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wev.d.w<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVADDWEV.Q.D ++;;TODO2 ++(define_insn "lasx_xvaddwev_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVADDWEV)) ++ "ISA_HAS_LASX" ++ "xvaddwev.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVSUBWEV.Q.D ++;;TODO2 ++(define_insn "lasx_xvsubwev_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVSUBWEV)) ++ "ISA_HAS_LASX" ++ "xvsubwev.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMULWEV.Q.D ++;;TODO2 ++(define_insn "lasx_xvmulwev_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVMULWEV)) ++ "ISA_HAS_LASX" ++ "xvmulwev.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++ ++;;XVADDWOD.H.B XVSUBWOD.H.B XVMULWOD.H.B ++;;XVADDWOD.H.BU XVSUBWOD.H.BU XVMULWOD.H.BU ++(define_insn "lasx_xv<optab>wod_h_b<u>" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (addsubmul:V16HI ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))) ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wod.h.b<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V16HI")) ++ ++;;XVADDWOD.W.H XVSUBWOD.W.H XVMULWOD.W.H ++;;XVADDWOD.W.HU XVSUBWOD.W.HU XVMULWOD.W.HU ++(define_insn "lasx_xv<optab>wod_w_h<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (addsubmul:V8SI ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wod.w.h<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8SI")) ++ ++ ++;;XVADDWOD.D.W XVSUBWOD.D.W XVMULWOD.D.W ++;;XVADDWOD.D.WU XVSUBWOD.D.WU XVMULWOD.D.WU ++(define_insn "lasx_xv<optab>wod_d_w<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (addsubmul:V4DI ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wod.d.w<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVADDWOD.Q.D ++;;TODO2 ++(define_insn "lasx_xvaddwod_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVADDWOD)) ++ "ISA_HAS_LASX" ++ "xvaddwod.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVSUBWOD.Q.D ++;;TODO2 ++(define_insn "lasx_xvsubwod_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVSUBWOD)) ++ "ISA_HAS_LASX" ++ "xvsubwod.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMULWOD.Q.D ++;;TODO2 ++(define_insn "lasx_xvmulwod_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVMULWOD)) ++ "ISA_HAS_LASX" ++ "xvmulwod.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVADDWEV.Q.DU ++;;TODO2 ++(define_insn "lasx_xvaddwev_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVADDWEV2)) ++ "ISA_HAS_LASX" ++ "xvaddwev.q.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVSUBWEV.Q.DU ++;;TODO2 ++(define_insn "lasx_xvsubwev_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVSUBWEV2)) ++ "ISA_HAS_LASX" ++ "xvsubwev.q.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMULWEV.Q.DU ++;;TODO2 ++(define_insn "lasx_xvmulwev_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVMULWEV2)) ++ "ISA_HAS_LASX" ++ "xvmulwev.q.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVADDWOD.Q.DU ++;;TODO2 ++(define_insn "lasx_xvaddwod_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVADDWOD2)) ++ "ISA_HAS_LASX" ++ "xvaddwod.q.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVSUBWOD.Q.DU ++;;TODO2 ++(define_insn "lasx_xvsubwod_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVSUBWOD2)) ++ "ISA_HAS_LASX" ++ "xvsubwod.q.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMULWOD.Q.DU ++;;TODO2 ++(define_insn "lasx_xvmulwod_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVMULWOD2)) ++ "ISA_HAS_LASX" ++ "xvmulwod.q.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVADDWEV.H.BU.B XVMULWEV.H.BU.B ++(define_insn "lasx_xv<optab>wev_h_bu_b" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (addmul:V16HI ++ (zero_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))) ++ (sign_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wev.h.bu.b\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V16HI")) ++ ++;;XVADDWEV.W.HU.H XVMULWEV.W.HU.H ++(define_insn "lasx_xv<optab>wev_w_hu_h" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (addmul:V8SI ++ (zero_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (sign_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wev.w.hu.h\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8SI")) ++ ++;;XVADDWEV.D.WU.W XVMULWEV.D.WU.W ++(define_insn "lasx_xv<optab>wev_d_wu_w" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (addmul:V4DI ++ (zero_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (sign_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wev.d.wu.w\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVADDWOD.H.BU.B XVMULWOD.H.BU.B ++(define_insn "lasx_xv<optab>wod_h_bu_b" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (addmul:V16HI ++ (zero_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))) ++ (sign_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wod.h.bu.b\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V16HI")) ++ ++;;XVADDWOD.W.HU.H XVMULWOD.W.HU.H ++(define_insn "lasx_xv<optab>wod_w_hu_h" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (addmul:V8SI ++ (zero_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (sign_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wod.w.hu.h\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8SI")) ++ ++;;XVADDWOD.D.WU.W XVMULWOD.D.WU.W ++(define_insn "lasx_xv<optab>wod_d_wu_w" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (addmul:V4DI ++ (zero_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (sign_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))))) ++ "ISA_HAS_LASX" ++ "xv<optab>wod.d.wu.w\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWEV.H.B XVMADDWEV.H.BU ++(define_insn "lasx_xvmaddwev_h_b<u>" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (plus:V16HI ++ (match_operand:V16HI 1 "register_operand" "0") ++ (mult:V16HI ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))) ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwev.h.b<u>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V16HI")) ++ ++;;XVMADDWEV.W.H XVMADDWEV.W.HU ++(define_insn "lasx_xvmaddwev_w_h<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (plus:V8SI ++ (match_operand:V8SI 1 "register_operand" "0") ++ (mult:V8SI ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwev.w.h<u>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8SI")) ++ ++;;XVMADDWEV.D.W XVMADDWEV.D.WU ++(define_insn "lasx_xvmaddwev_d_w<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (plus:V4DI ++ (match_operand:V4DI 1 "register_operand" "0") ++ (mult:V4DI ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwev.d.w<u>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWEV.Q.D ++;;TODO2 ++(define_insn "lasx_xvmaddwev_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "0") ++ (match_operand:V4DI 2 "register_operand" "f") ++ (match_operand:V4DI 3 "register_operand" "f") ++ UNSPEC_LASX_XVMADDWEV)) ++ "ISA_HAS_LASX" ++ "xvmaddwev.q.d\t%u0,%u2,%u3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWOD.H.B XVMADDWOD.H.BU ++(define_insn "lasx_xvmaddwod_h_b<u>" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (plus:V16HI ++ (match_operand:V16HI 1 "register_operand" "0") ++ (mult:V16HI ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))) ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwod.h.b<u>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V16HI")) ++ ++;;XVMADDWOD.W.H XVMADDWOD.W.HU ++(define_insn "lasx_xvmaddwod_w_h<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (plus:V8SI ++ (match_operand:V8SI 1 "register_operand" "0") ++ (mult:V8SI ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwod.w.h<u>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8SI")) ++ ++;;XVMADDWOD.D.W XVMADDWOD.D.WU ++(define_insn "lasx_xvmaddwod_d_w<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (plus:V4DI ++ (match_operand:V4DI 1 "register_operand" "0") ++ (mult:V4DI ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwod.d.w<u>\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWOD.Q.D ++;;TODO2 ++(define_insn "lasx_xvmaddwod_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "0") ++ (match_operand:V4DI 2 "register_operand" "f") ++ (match_operand:V4DI 3 "register_operand" "f") ++ UNSPEC_LASX_XVMADDWOD)) ++ "ISA_HAS_LASX" ++ "xvmaddwod.q.d\t%u0,%u2,%u3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWEV.Q.DU ++;;TODO2 ++(define_insn "lasx_xvmaddwev_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "0") ++ (match_operand:V4DI 2 "register_operand" "f") ++ (match_operand:V4DI 3 "register_operand" "f") ++ UNSPEC_LASX_XVMADDWEV2)) ++ "ISA_HAS_LASX" ++ "xvmaddwev.q.du\t%u0,%u2,%u3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWOD.Q.DU ++;;TODO2 ++(define_insn "lasx_xvmaddwod_q_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "0") ++ (match_operand:V4DI 2 "register_operand" "f") ++ (match_operand:V4DI 3 "register_operand" "f") ++ UNSPEC_LASX_XVMADDWOD2)) ++ "ISA_HAS_LASX" ++ "xvmaddwod.q.du\t%u0,%u2,%u3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWEV.H.BU.B ++(define_insn "lasx_xvmaddwev_h_bu_b" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (plus:V16HI ++ (match_operand:V16HI 1 "register_operand" "0") ++ (mult:V16HI ++ (zero_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))) ++ (sign_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwev.h.bu.b\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V16HI")) ++ ++;;XVMADDWEV.W.HU.H ++(define_insn "lasx_xvmaddwev_w_hu_h" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (plus:V8SI ++ (match_operand:V8SI 1 "register_operand" "0") ++ (mult:V8SI ++ (zero_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (sign_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwev.w.hu.h\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8SI")) ++ ++;;XVMADDWEV.D.WU.W ++(define_insn "lasx_xvmaddwev_d_wu_w" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (plus:V4DI ++ (match_operand:V4DI 1 "register_operand" "0") ++ (mult:V4DI ++ (zero_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (sign_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwev.d.wu.w\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWEV.Q.DU.D ++;;TODO2 ++(define_insn "lasx_xvmaddwev_q_du_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "0") ++ (match_operand:V4DI 2 "register_operand" "f") ++ (match_operand:V4DI 3 "register_operand" "f") ++ UNSPEC_LASX_XVMADDWEV3)) ++ "ISA_HAS_LASX" ++ "xvmaddwev.q.du.d\t%u0,%u2,%u3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWOD.H.BU.B ++(define_insn "lasx_xvmaddwod_h_bu_b" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (plus:V16HI ++ (match_operand:V16HI 1 "register_operand" "0") ++ (mult:V16HI ++ (zero_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))) ++ (sign_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwod.h.bu.b\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V16HI")) ++ ++;;XVMADDWOD.W.HU.H ++(define_insn "lasx_xvmaddwod_w_hu_h" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (plus:V8SI ++ (match_operand:V8SI 1 "register_operand" "0") ++ (mult:V8SI ++ (zero_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (sign_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwod.w.hu.h\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8SI")) ++ ++;;XVMADDWOD.D.WU.W ++(define_insn "lasx_xvmaddwod_d_wu_w" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (plus:V4DI ++ (match_operand:V4DI 1 "register_operand" "0") ++ (mult:V4DI ++ (zero_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (sign_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7))))))) ++ "ISA_HAS_LASX" ++ "xvmaddwod.d.wu.w\t%u0,%u2,%u3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMADDWOD.Q.DU.D ++;;TODO2 ++(define_insn "lasx_xvmaddwod_q_du_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "0") ++ (match_operand:V4DI 2 "register_operand" "f") ++ (match_operand:V4DI 3 "register_operand" "f") ++ UNSPEC_LASX_XVMADDWOD3)) ++ "ISA_HAS_LASX" ++ "xvmaddwod.q.du.d\t%u0,%u2,%u3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVHADDW.Q.D ++;;TODO2 ++(define_insn "lasx_xvhaddw_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVHADDW_Q_D)) ++ "ISA_HAS_LASX" ++ "xvhaddw.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVHSUBW.Q.D ++;;TODO2 ++(define_insn "lasx_xvhsubw_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVHSUBW_Q_D)) ++ "ISA_HAS_LASX" ++ "xvhsubw.q.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVHADDW.QU.DU ++;;TODO2 ++(define_insn "lasx_xvhaddw_qu_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVHADDW_QU_DU)) ++ "ISA_HAS_LASX" ++ "xvhaddw.qu.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVHSUBW.QU.DU ++;;TODO2 ++(define_insn "lasx_xvhsubw_qu_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVHSUBW_QU_DU)) ++ "ISA_HAS_LASX" ++ "xvhsubw.qu.du\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVROTR.B XVROTR.H XVROTR.W XVROTR.D ++;;TODO-478 ++(define_insn "lasx_xvrotr_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand:ILASX 2 "register_operand" "f") ++ UNSPEC_LASX_XVROTR)) ++ "ISA_HAS_LASX" ++ "xvrotr.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++;;XVADD.Q ++;;TODO2 ++(define_insn "lasx_xvadd_q" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVADD_Q)) ++ "ISA_HAS_LASX" ++ "xvadd.q\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVSUB.Q ++;;TODO2 ++(define_insn "lasx_xvsub_q" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVSUB_Q)) ++ "ISA_HAS_LASX" ++ "xvsub.q\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVSSRLN.B.H XVSSRLN.H.W XVSSRLN.W.D ++(define_insn "lasx_xvssrln_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRLN)) ++ "ISA_HAS_LASX" ++ "xvssrln.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++;;XVREPLVE.B XVREPLVE.H XVREPLVE.W XVREPLVE.D ++(define_insn "lasx_xvreplve_<lasxfmt_f>" ++ (set (match_operand:LASX 0 "register_operand" "=f") ++ (unspec:LASX (match_operand:LASX 1 "register_operand" "f") ++ (match_operand:SI 2 "register_operand" "r") ++ UNSPEC_LASX_XVREPLVE)) ++ "ISA_HAS_LASX" ++ "xvreplve.<lasxfmt>\t%u0,%u1,%z2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++;;XVADDWEV.Q.DU.D ++(define_insn "lasx_xvaddwev_q_du_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVADDWEV3)) ++ "ISA_HAS_LASX" ++ "xvaddwev.q.du.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVADDWOD.Q.DU.D ++(define_insn "lasx_xvaddwod_q_du_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVADDWOD3)) ++ "ISA_HAS_LASX" ++ "xvaddwod.q.du.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMULWEV.Q.DU.D ++(define_insn "lasx_xvmulwev_q_du_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVMULWEV3)) ++ "ISA_HAS_LASX" ++ "xvmulwev.q.du.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;;XVMULWOD.Q.DU.D ++(define_insn "lasx_xvmulwod_q_du_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ (match_operand:V4DI 2 "register_operand" "f") ++ UNSPEC_LASX_XVMULWOD3)) ++ "ISA_HAS_LASX" ++ "xvmulwod.q.du.d\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvpickve2gr_w<u>" ++ (set (match_operand:SI 0 "register_operand" "=r") ++ (any_extend:SI ++ (vec_select:SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_0_to_7_operand" ""))))) ++ "ISA_HAS_LASX" ++ "xvpickve2gr.w<u>\t%0,%u1,%2" ++ (set_attr "type" "simd_copy") ++ (set_attr "mode" "V8SI")) ++ ++ ++(define_insn "lasx_xvmskgez_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (unspec:V32QI (match_operand:V32QI 1 "register_operand" "f") ++ UNSPEC_LASX_XVMSKGEZ)) ++ "ISA_HAS_LASX" ++ "xvmskgez.b\t%u0,%u1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvmsknz_b" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (unspec:V32QI (match_operand:V32QI 1 "register_operand" "f") ++ UNSPEC_LASX_XVMSKNZ)) ++ "ISA_HAS_LASX" ++ "xvmsknz.b\t%u0,%u1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvexth_h<u>_b<u>" ++ (set (match_operand:V16HI 0 "register_operand" "=f") ++ (any_extend:V16HI ++ (vec_select:V16QI ++ (match_operand:V32QI 1 "register_operand" "f") ++ (parallel (const_int 16) (const_int 17) ++ (const_int 18) (const_int 19) ++ (const_int 20) (const_int 21) ++ (const_int 22) (const_int 23) ++ (const_int 24) (const_int 25) ++ (const_int 26) (const_int 27) ++ (const_int 28) (const_int 29) ++ (const_int 30) (const_int 31))))) ++ "ISA_HAS_LASX" ++ "xvexth.h<u>.b<u>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V16HI")) ++ ++(define_insn "lasx_xvexth_w<u>_h<u>" ++ (set (match_operand:V8SI 0 "register_operand" "=f") ++ (any_extend:V8SI ++ (vec_select:V8HI ++ (match_operand:V16HI 1 "register_operand" "f") ++ (parallel (const_int 8) (const_int 9) ++ (const_int 10) (const_int 11) ++ (const_int 12) (const_int 13) ++ (const_int 14) (const_int 15))))) ++ "ISA_HAS_LASX" ++ "xvexth.w<u>.h<u>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V8SI")) ++ ++(define_insn "lasx_xvexth_d<u>_w<u>" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "f") ++ (parallel (const_int 4) (const_int 5) ++ (const_int 6) (const_int 7))))) ++ "ISA_HAS_LASX" ++ "xvexth.d<u>.w<u>\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvexth_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ UNSPEC_LASX_XVEXTH_Q_D)) ++ "ISA_HAS_LASX" ++ "xvexth.q.d\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvexth_qu_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ UNSPEC_LASX_XVEXTH_QU_DU)) ++ "ISA_HAS_LASX" ++ "xvexth.qu.du\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvrotri_<lasxfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (rotatert:ILASX (match_operand:ILASX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm256>_operand" ""))) ++ "ISA_HAS_LASX" ++ "xvrotri.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvextl_q_d" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ UNSPEC_LASX_XVEXTL_Q_D)) ++ "ISA_HAS_LASX" ++ "xvextl.q.d\t%u0,%u1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvsrlni_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSRLNI)) ++ "ISA_HAS_LASX" ++ "xvsrlni.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrlrni_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSRLRNI)) ++ "ISA_HAS_LASX" ++ "xvsrlrni.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrlni_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRLNI)) ++ "ISA_HAS_LASX" ++ "xvssrlni.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrlni_<lasxfmt_u>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRLNI2)) ++ "ISA_HAS_LASX" ++ "xvssrlni.<lasxfmt_u>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrlrni_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRLRNI)) ++ "ISA_HAS_LASX" ++ "xvssrlrni.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrlrni_<lasxfmt_u>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRLRNI2)) ++ "ISA_HAS_LASX" ++ "xvssrlrni.<lasxfmt_u>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrani_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSRANI)) ++ "ISA_HAS_LASX" ++ "xvsrani.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvsrarni_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSRARNI)) ++ "ISA_HAS_LASX" ++ "xvsrarni.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrani_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRANI)) ++ "ISA_HAS_LASX" ++ "xvssrani.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrani_<lasxfmt_u>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRANI2)) ++ "ISA_HAS_LASX" ++ "xvssrani.<lasxfmt_u>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrarni_<lasxfmt>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRARNI)) ++ "ISA_HAS_LASX" ++ "xvssrarni.<lasxfmt>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrarni_<lasxfmt_u>_<dlasxqfmt>" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (unspec:ILASX (match_operand:ILASX 1 "register_operand" "0") ++ (match_operand:ILASX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVSSRARNI2)) ++ "ISA_HAS_LASX" ++ "xvssrarni.<lasxfmt_u>.<dlasxqfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_mode_attr VDOUBLEMODEW256 ++ (V8SI "V16SI") ++ (V8SF "V16SF")) ++ ++(define_insn "lasx_xvpermi_<lasxfmt_f_wd>" ++ (set (match_operand:LASX_W 0 "register_operand" "=f") ++ (unspec:LASX_W (match_operand:LASX_W 1 "register_operand" "0") ++ (match_operand:LASX_W 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LASX_XVPERMI)) ++ "ISA_HAS_LASX" ++ "xvpermi.w\t%u0,%u2,%3" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvpermi_<lasxfmt_f_wd>_1" ++ (set (match_operand:LASX_W 0 "register_operand" "=f") ++ (vec_select:LASX_W ++ (vec_concat:<VDOUBLEMODEW256> ++ (match_operand:LASX_W 1 "register_operand" "f") ++ (match_operand:LASX_W 2 "register_operand" "0")) ++ (parallel (match_operand 3 "const_0_to_3_operand") ++ (match_operand 4 "const_0_to_3_operand" ) ++ (match_operand 5 "const_8_to_11_operand" ) ++ (match_operand 6 "const_8_to_11_operand" ) ++ (match_operand 7 "const_4_to_7_operand" ) ++ (match_operand 8 "const_4_to_7_operand" ) ++ (match_operand 9 "const_12_to_15_operand") ++ (match_operand 10 "const_12_to_15_operand")))) ++ "ISA_HAS_LASX ++ && INTVAL (operands3) + 4 == INTVAL (operands7) ++ && INTVAL (operands4) + 4 == INTVAL (operands8) ++ && INTVAL (operands5) + 4 == INTVAL (operands9) ++ && INTVAL (operands6) + 4 == INTVAL (operands10)" ++{ ++ int mask = 0; ++ mask |= INTVAL (operands3) << 0; ++ mask |= INTVAL (operands4) << 2; ++ mask |= (INTVAL (operands5) - 8) << 4; ++ mask |= (INTVAL (operands6) - 8) << 6; ++ operands3 = GEN_INT (mask); ++ ++ return "xvpermi.w\t%u0,%u1,%3"; ++} ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_expand "lasx_xvld" ++ (match_operand:V32QI 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq12b_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (operands0, gen_rtx_MEM (V32QImode, addr)); ++ DONE; ++}) ++ ++(define_expand "lasx_xvst" ++ (match_operand:V32QI 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq12b_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (gen_rtx_MEM (V32QImode, addr), operands0); ++ DONE; ++}) ++ ++(define_expand "lasx_xvstelm_<lasxfmt_f>" ++ (match_operand:LASX 0 "register_operand") ++ (match_operand 3 "const_<indeximm256>_operand") ++ (match_operand 2 "aq8<lasxfmt>_operand") ++ (match_operand 1 "pmode_register_operand") ++ "ISA_HAS_LASX" ++{ ++ emit_insn (gen_lasx_xvstelm_<lasxfmt_f>_insn ++ (operands1, operands2, operands0, operands3)); ++ DONE; ++}) ++ ++(define_insn "lasx_xvstelm_<lasxfmt_f>_insn" ++ (set (mem:<UNITMODE> (plus:DI (match_operand:DI 0 "register_operand" "r") ++ (match_operand 1 "aq8<lasxfmt>_operand"))) ++ (vec_select:<UNITMODE> ++ (match_operand:LASX 2 "register_operand" "f") ++ (parallel (match_operand 3 "const_<indeximm256>_operand" "")))) ++ "ISA_HAS_LASX" ++{ ++ return "xvstelm.<lasxfmt>\t%u2,%0,%1,%3"; ++} ++ (set_attr "type" "simd_store") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++;; Offset is "0" ++(define_insn "lasx_xvstelm_<lasxfmt_f>_insn_0" ++ (set (mem:<UNITMODE> (match_operand:DI 0 "register_operand" "r")) ++ (vec_select:<UNITMODE> ++ (match_operand:LASX_WD 1 "register_operand" "f") ++ (parallel (match_operand:SI 2 "const_<indeximm256>_operand")))) ++ "ISA_HAS_LASX" ++{ ++ return "xvstelm.<lasxfmt>\t%u1,%0,0,%2"; ++} ++ (set_attr "type" "simd_store") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++(define_insn "lasx_xvinsve0_<lasxfmt_f>" ++ (set (match_operand:LASX_WD 0 "register_operand" "=f") ++ (unspec:LASX_WD (match_operand:LASX_WD 1 "register_operand" "0") ++ (match_operand:LASX_WD 2 "register_operand" "f") ++ (match_operand 3 "const_<indeximm256>_operand" "") ++ UNSPEC_LASX_XVINSVE0)) ++ "ISA_HAS_LASX" ++ "xvinsve0.<lasxfmt>\t%u0,%u2,%3" ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvinsve0_<lasxfmt_f>_scalar" ++ (set (match_operand:FLASX 0 "register_operand" "=f") ++ (vec_merge:FLASX ++ (vec_duplicate:FLASX ++ (match_operand:<UNITMODE> 1 "register_operand" "f")) ++ (match_operand:FLASX 2 "register_operand" "0") ++ (match_operand 3 "const_<bitmask256>_operand" ""))) ++ "ISA_HAS_LASX" ++ "xvinsve0.<lasxfmt>\t%u0,%u1,%y3" ++ (set_attr "type" "simd_insert") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvpickve_<lasxfmt_f>" ++ (set (match_operand:LASX_WD 0 "register_operand" "=f") ++ (unspec:LASX_WD (match_operand:LASX_WD 1 "register_operand" "f") ++ (match_operand 2 "const_<indeximm256>_operand" "") ++ UNSPEC_LASX_XVPICKVE)) ++ "ISA_HAS_LASX" ++ "xvpickve.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvpickve_<lasxfmt_f>_scalar" ++ (set (match_operand:<UNITMODE> 0 "register_operand" "=f") ++ (vec_select:<UNITMODE> ++ (match_operand:FLASX 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_<indeximm256>_operand" "")))) ++ "ISA_HAS_LASX" ++ "xvpickve.<lasxfmt>\t%u0,%u1,%2" ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvssrlrn_<hlasxfmt>_<lasxfmt>" ++ (set (match_operand:<VHSMODE256> 0 "register_operand" "=f") ++ (unspec:<VHSMODE256> (match_operand:ILASX_DWH 1 "register_operand" "f") ++ (match_operand:ILASX_DWH 2 "register_operand" "f") ++ UNSPEC_LASX_XVSSRLRN)) ++ "ISA_HAS_LASX" ++ "xvssrlrn.<hlasxfmt>.<lasxfmt>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "xvorn<mode>3" ++ (set (match_operand:ILASX 0 "register_operand" "=f") ++ (ior:ILASX (not:ILASX (match_operand:ILASX 2 "register_operand" "f")) ++ (match_operand:ILASX 1 "register_operand" "f"))) ++ "ISA_HAS_LASX" ++ "xvorn.v\t%u0,%u1,%u2" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lasx_xvextl_qu_du" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI (match_operand:V4DI 1 "register_operand" "f") ++ UNSPEC_LASX_XVEXTL_QU_DU)) ++ "ISA_HAS_LASX" ++ "xvextl.qu.du\t%u0,%u1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvldi" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (unspec:V4DI(match_operand 1 "const_imm13_operand") ++ UNSPEC_LASX_XVLDI)) ++ "ISA_HAS_LASX" ++{ ++ HOST_WIDE_INT val = INTVAL (operands1); ++ if (val < 0) ++ { ++ HOST_WIDE_INT modeVal = (val & 0xf00) >> 8; ++ if (modeVal < 13) ++ return "xvldi\t%u0,%1"; ++ else ++ { ++ sorry ("imm13 only support 0000 ~ 1100 in bits '12 ~ 9' when bit '13' is 1"); ++ return "#"; ++ } ++ } ++ else ++ return "xvldi\t%u0,%1"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "V4DI")) ++ ++(define_insn "lasx_xvldx" ++ (set (match_operand:V32QI 0 "register_operand" "=f") ++ (unspec:V32QI (match_operand:DI 1 "register_operand" "r") ++ (match_operand:DI 2 "reg_or_0_operand" "rJ") ++ UNSPEC_LASX_XVLDX)) ++ "ISA_HAS_LASX" ++{ ++ return "xvldx\t%u0,%1,%z2"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "V32QI")) ++ ++(define_insn "lasx_xvstx" ++ (set (mem:V32QI (plus:DI (match_operand:DI 1 "register_operand" "r") ++ (match_operand:DI 2 "reg_or_0_operand" "rJ"))) ++ (unspec: V32QI(match_operand:V32QI 0 "register_operand" "f") ++ UNSPEC_LASX_XVSTX)) ++ ++ "ISA_HAS_LASX" ++{ ++ return "xvstx\t%u0,%1,%z2"; ++} ++ (set_attr "type" "simd_store") ++ (set_attr "mode" "DI")) ++ ++(define_insn "vec_widen_<su>mult_even_v8si" ++ (set (match_operand:V4DI 0 "register_operand" "=f") ++ (mult:V4DI ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (any_extend:V4DI ++ (vec_select:V4SI ++ (match_operand:V8SI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))))) ++ "ISA_HAS_LASX" ++ "xvmulwev.d.w<u>\t%u0,%u1,%u2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4DI")) ++ ++;; Vector reduction operation ++(define_expand "reduc_plus_scal_v4di" ++ (match_operand:DI 0 "register_operand") ++ (match_operand:V4DI 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (V4DImode); ++ rtx tmp1 = gen_reg_rtx (V4DImode); ++ rtx vec_res = gen_reg_rtx (V4DImode); ++ emit_insn (gen_lasx_xvhaddw_q_d (tmp, operands1, operands1)); ++ emit_insn (gen_lasx_xvpermi_d_v4di (tmp1, tmp, GEN_INT (2))); ++ emit_insn (gen_addv4di3 (vec_res, tmp, tmp1)); ++ emit_insn (gen_vec_extractv4didi (operands0, vec_res, const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_plus_scal_v8si" ++ (match_operand:SI 0 "register_operand") ++ (match_operand:V8SI 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (V4DImode); ++ rtx tmp1 = gen_reg_rtx (V4DImode); ++ rtx vec_res = gen_reg_rtx (V4DImode); ++ emit_insn (gen_lasx_xvhaddw_d_w (tmp, operands1, operands1)); ++ emit_insn (gen_lasx_xvhaddw_q_d (tmp1, tmp, tmp)); ++ emit_insn (gen_lasx_xvpermi_d_v4di (tmp, tmp1, GEN_INT (2))); ++ emit_insn (gen_addv4di3 (vec_res, tmp, tmp1)); ++ emit_insn (gen_vec_extractv8sisi (operands0, gen_lowpart (V8SImode,vec_res), ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_plus_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:FLASX 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_add<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_<optab>_scal_<mode>" ++ (any_bitwise:<UNITMODE> ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:ILASX 1 "register_operand")) ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_<optab><mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_smax_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:LASX 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_smax<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_smin_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:LASX 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_smin<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_umax_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:ILASX 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_umax<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_umin_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:ILASX 1 "register_operand") ++ "ISA_HAS_LASX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_umin<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) +diff --git a/gcc/config/loongarch/loongarch-modes.def b/gcc/config/loongarch/loongarch-modes.def +index b69ad3d83..ac9ea3142 100644 +--- a/gcc/config/loongarch/loongarch-modes.def ++++ b/gcc/config/loongarch/loongarch-modes.def +@@ -33,6 +33,7 @@ VECTOR_MODES (FLOAT, 8); /* V4HF V2SF */ + VECTOR_MODES (INT, 16); /* V16QI V8HI V4SI V2DI */ + VECTOR_MODES (FLOAT, 16); /* V4SF V2DF */ + ++/* For LARCH LASX 256 bits. */ + VECTOR_MODES (INT, 32); /* V32QI V16HI V8SI V4DI */ + VECTOR_MODES (FLOAT, 32); /* V8SF V4DF */ + +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 24e42fa99..133ec9fa8 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -89,6 +89,8 @@ extern bool loongarch_split_move_insn_p (rtx, rtx); + extern void loongarch_split_move_insn (rtx, rtx, rtx); + extern void loongarch_split_128bit_move (rtx, rtx); + extern bool loongarch_split_128bit_move_p (rtx, rtx); ++extern void loongarch_split_256bit_move (rtx, rtx); ++extern bool loongarch_split_256bit_move_p (rtx, rtx); + extern void loongarch_split_lsx_copy_d (rtx, rtx, rtx, rtx (*)(rtx, rtx, rtx)); + extern void loongarch_split_lsx_insert_d (rtx, rtx, rtx, rtx); + extern void loongarch_split_lsx_fill_d (rtx, rtx); +@@ -174,9 +176,11 @@ union loongarch_gen_fn_ptrs + extern void loongarch_expand_atomic_qihi (union loongarch_gen_fn_ptrs, + rtx, rtx, rtx, rtx, rtx); + ++extern void loongarch_expand_vector_group_init (rtx, rtx); + extern void loongarch_expand_vector_init (rtx, rtx); + extern void loongarch_expand_vec_unpack (rtx op2, bool, bool); + extern void loongarch_expand_vec_perm (rtx, rtx, rtx, rtx); ++extern void loongarch_expand_vec_perm_1 (rtx); + extern void loongarch_expand_vector_extract (rtx, rtx, int); + extern void loongarch_expand_vector_reduc (rtx (*)(rtx, rtx, rtx), rtx, rtx); + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 40b83d72b..dae35a479 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -1927,7 +1927,7 @@ loongarch_symbol_insns (enum loongarch_symbol_type type, machine_mode mode) + { + /* LSX LD.* and ST.* cannot support loading symbols via an immediate + operand. */ +- if (LSX_SUPPORTED_MODE_P (mode)) ++ if (LSX_SUPPORTED_MODE_P (mode) || LASX_SUPPORTED_MODE_P (mode)) + return 0; + + switch (type) +@@ -2060,6 +2060,11 @@ loongarch_valid_offset_p (rtx x, machine_mode mode) + loongarch_ldst_scaled_shift (mode))) + return false; + ++ /* LASX XVLD.B and XVST.B supports 10-bit signed offsets without shift. */ ++ if (LASX_SUPPORTED_MODE_P (mode) ++ && !loongarch_signed_immediate_p (INTVAL (x), 10, 0)) ++ return false; ++ + return true; + } + +@@ -2272,7 +2277,9 @@ loongarch_address_insns (rtx x, machine_mode mode, bool might_split_p) + { + struct loongarch_address_info addr; + int factor; +- bool lsx_p = !might_split_p && LSX_SUPPORTED_MODE_P (mode); ++ bool lsx_p = (!might_split_p ++ && (LSX_SUPPORTED_MODE_P (mode) ++ || LASX_SUPPORTED_MODE_P (mode))); + + if (!loongarch_classify_address (&addr, x, mode, false)) + return 0; +@@ -2418,7 +2425,8 @@ loongarch_const_insns (rtx x) + return loongarch_integer_cost (INTVAL (x)); + + case CONST_VECTOR: +- if (LSX_SUPPORTED_MODE_P (GET_MODE (x)) ++ if ((LSX_SUPPORTED_MODE_P (GET_MODE (x)) ++ || LASX_SUPPORTED_MODE_P (GET_MODE (x))) + && loongarch_const_vector_same_int_p (x, GET_MODE (x), -512, 511)) + return 1; + /* Fall through. */ +@@ -3257,10 +3265,11 @@ loongarch_legitimize_move (machine_mode mode, rtx dest, rtx src) + + /* Both src and dest are non-registers; one special case is supported where + the source is (const_int 0) and the store can source the zero register. +- LSX is never able to source the zero register directly in ++ LSX and LASX are never able to source the zero register directly in + memory operations. */ + if (!register_operand (dest, mode) && !register_operand (src, mode) +- && (!const_0_operand (src, mode) || LSX_SUPPORTED_MODE_P (mode))) ++ && (!const_0_operand (src, mode) ++ || LSX_SUPPORTED_MODE_P (mode) || LASX_SUPPORTED_MODE_P (mode))) + { + loongarch_emit_move (dest, force_reg (mode, src)); + return true; +@@ -3842,6 +3851,7 @@ loongarch_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost, + int misalign ATTRIBUTE_UNUSED) + { + unsigned elements; ++ machine_mode mode = vectype != NULL ? TYPE_MODE (vectype) : DImode; + + switch (type_of_cost) + { +@@ -3858,7 +3868,8 @@ loongarch_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost, + return 1; + + case vec_perm: +- return 1; ++ return LASX_SUPPORTED_MODE_P (mode) ++ && !LSX_SUPPORTED_MODE_P (mode) ? 2 : 1; + + case unaligned_load: + case vector_gather_load: +@@ -3939,6 +3950,10 @@ loongarch_split_move_p (rtx dest, rtx src) + if (LSX_SUPPORTED_MODE_P (GET_MODE (dest))) + return loongarch_split_128bit_move_p (dest, src); + ++ /* Check if LASX moves need splitting. */ ++ if (LASX_SUPPORTED_MODE_P (GET_MODE (dest))) ++ return loongarch_split_256bit_move_p (dest, src); ++ + /* Otherwise split all multiword moves. */ + return size > UNITS_PER_WORD; + } +@@ -3954,6 +3969,8 @@ loongarch_split_move (rtx dest, rtx src, rtx insn_) + gcc_checking_assert (loongarch_split_move_p (dest, src)); + if (LSX_SUPPORTED_MODE_P (GET_MODE (dest))) + loongarch_split_128bit_move (dest, src); ++ else if (LASX_SUPPORTED_MODE_P (GET_MODE (dest))) ++ loongarch_split_256bit_move (dest, src); + else if (FP_REG_RTX_P (dest) || FP_REG_RTX_P (src)) + { + if (!TARGET_64BIT && GET_MODE (dest) == DImode) +@@ -4119,7 +4136,7 @@ const char * + loongarch_output_move_index_float (rtx x, machine_mode mode, bool ldr) + { + int index = exact_log2 (GET_MODE_SIZE (mode)); +- if (!IN_RANGE (index, 2, 4)) ++ if (!IN_RANGE (index, 2, 5)) + return NULL; + + struct loongarch_address_info info; +@@ -4128,17 +4145,19 @@ loongarch_output_move_index_float (rtx x, machine_mode mode, bool ldr) + || !loongarch_legitimate_address_p (mode, x, false)) + return NULL; + +- const char *const insn3 = ++ const char *const insn4 = + { + { + "fstx.s\t%1,%0", + "fstx.d\t%1,%0", +- "vstx\t%w1,%0" ++ "vstx\t%w1,%0", ++ "xvstx\t%u1,%0" + }, + { + "fldx.s\t%0,%1", + "fldx.d\t%0,%1", +- "vldx\t%w0,%1" ++ "vldx\t%w0,%1", ++ "xvldx\t%u0,%1" + } + }; + +@@ -4172,6 +4191,34 @@ loongarch_split_128bit_move_p (rtx dest, rtx src) + return true; + } + ++/* Return true if a 256-bit move from SRC to DEST should be split. */ ++ ++bool ++loongarch_split_256bit_move_p (rtx dest, rtx src) ++{ ++ /* LSX-to-LSX moves can be done in a single instruction. */ ++ if (FP_REG_RTX_P (src) && FP_REG_RTX_P (dest)) ++ return false; ++ ++ /* Check for LSX loads and stores. */ ++ if (FP_REG_RTX_P (dest) && MEM_P (src)) ++ return false; ++ if (FP_REG_RTX_P (src) && MEM_P (dest)) ++ return false; ++ ++ /* Check for LSX set to an immediate const vector with valid replicated ++ element. */ ++ if (FP_REG_RTX_P (dest) ++ && loongarch_const_vector_same_int_p (src, GET_MODE (src), -512, 511)) ++ return false; ++ ++ /* Check for LSX load zero immediate. */ ++ if (FP_REG_RTX_P (dest) && src == CONST0_RTX (GET_MODE (src))) ++ return false; ++ ++ return true; ++} ++ + /* Split a 128-bit move from SRC to DEST. */ + + void +@@ -4263,6 +4310,97 @@ loongarch_split_128bit_move (rtx dest, rtx src) + } + } + ++/* Split a 256-bit move from SRC to DEST. */ ++ ++void ++loongarch_split_256bit_move (rtx dest, rtx src) ++{ ++ int byte, index; ++ rtx low_dest, low_src, d, s; ++ ++ if (FP_REG_RTX_P (dest)) ++ { ++ gcc_assert (!MEM_P (src)); ++ ++ rtx new_dest = dest; ++ if (!TARGET_64BIT) ++ { ++ if (GET_MODE (dest) != V8SImode) ++ new_dest = simplify_gen_subreg (V8SImode, dest, GET_MODE (dest), 0); ++ } ++ else ++ { ++ if (GET_MODE (dest) != V4DImode) ++ new_dest = simplify_gen_subreg (V4DImode, dest, GET_MODE (dest), 0); ++ } ++ ++ for (byte = 0, index = 0; byte < GET_MODE_SIZE (GET_MODE (dest)); ++ byte += UNITS_PER_WORD, index++) ++ { ++ s = loongarch_subword_at_byte (src, byte); ++ if (!TARGET_64BIT) ++ emit_insn (gen_lasx_xvinsgr2vr_w (new_dest, s, new_dest, ++ GEN_INT (1 << index))); ++ else ++ emit_insn (gen_lasx_xvinsgr2vr_d (new_dest, s, new_dest, ++ GEN_INT (1 << index))); ++ } ++ } ++ else if (FP_REG_RTX_P (src)) ++ { ++ gcc_assert (!MEM_P (dest)); ++ ++ rtx new_src = src; ++ if (!TARGET_64BIT) ++ { ++ if (GET_MODE (src) != V8SImode) ++ new_src = simplify_gen_subreg (V8SImode, src, GET_MODE (src), 0); ++ } ++ else ++ { ++ if (GET_MODE (src) != V4DImode) ++ new_src = simplify_gen_subreg (V4DImode, src, GET_MODE (src), 0); ++ } ++ ++ for (byte = 0, index = 0; byte < GET_MODE_SIZE (GET_MODE (src)); ++ byte += UNITS_PER_WORD, index++) ++ { ++ d = loongarch_subword_at_byte (dest, byte); ++ if (!TARGET_64BIT) ++ emit_insn (gen_lsx_vpickve2gr_w (d, new_src, GEN_INT (index))); ++ else ++ emit_insn (gen_lsx_vpickve2gr_d (d, new_src, GEN_INT (index))); ++ } ++ } ++ else ++ { ++ low_dest = loongarch_subword_at_byte (dest, 0); ++ low_src = loongarch_subword_at_byte (src, 0); ++ gcc_assert (REG_P (low_dest) && REG_P (low_src)); ++ /* Make sure the source register is not written before reading. */ ++ if (REGNO (low_dest) <= REGNO (low_src)) ++ { ++ for (byte = 0; byte < GET_MODE_SIZE (TImode); ++ byte += UNITS_PER_WORD) ++ { ++ d = loongarch_subword_at_byte (dest, byte); ++ s = loongarch_subword_at_byte (src, byte); ++ loongarch_emit_move (d, s); ++ } ++ } ++ else ++ { ++ for (byte = GET_MODE_SIZE (TImode) - UNITS_PER_WORD; byte >= 0; ++ byte -= UNITS_PER_WORD) ++ { ++ d = loongarch_subword_at_byte (dest, byte); ++ s = loongarch_subword_at_byte (src, byte); ++ loongarch_emit_move (d, s); ++ } ++ } ++ } ++} ++ + + /* Split a COPY_S.D with operands DEST, SRC and INDEX. GEN is a function + used to generate subregs. */ +@@ -4350,11 +4488,12 @@ loongarch_output_move (rtx dest, rtx src) + machine_mode mode = GET_MODE (dest); + bool dbl_p = (GET_MODE_SIZE (mode) == 8); + bool lsx_p = LSX_SUPPORTED_MODE_P (mode); ++ bool lasx_p = LASX_SUPPORTED_MODE_P (mode); + + if (loongarch_split_move_p (dest, src)) + return "#"; + +- if ((lsx_p) ++ if ((lsx_p || lasx_p) + && dest_code == REG && FP_REG_P (REGNO (dest)) + && src_code == CONST_VECTOR + && CONST_INT_P (CONST_VECTOR_ELT (src, 0))) +@@ -4364,6 +4503,8 @@ loongarch_output_move (rtx dest, rtx src) + { + case 16: + return "vrepli.%v0\t%w0,%E1"; ++ case 32: ++ return "xvrepli.%v0\t%u0,%E1"; + default: gcc_unreachable (); + } + } +@@ -4378,13 +4519,15 @@ loongarch_output_move (rtx dest, rtx src) + + if (FP_REG_P (REGNO (dest))) + { +- if (lsx_p) ++ if (lsx_p || lasx_p) + { + gcc_assert (src == CONST0_RTX (GET_MODE (src))); + switch (GET_MODE_SIZE (mode)) + { + case 16: + return "vrepli.b\t%w0,0"; ++ case 32: ++ return "xvrepli.b\t%u0,0"; + default: + gcc_unreachable (); + } +@@ -4517,12 +4660,14 @@ loongarch_output_move (rtx dest, rtx src) + { + if (dest_code == REG && FP_REG_P (REGNO (dest))) + { +- if (lsx_p) ++ if (lsx_p || lasx_p) + { + switch (GET_MODE_SIZE (mode)) + { + case 16: + return "vori.b\t%w0,%w1,0"; ++ case 32: ++ return "xvori.b\t%u0,%u1,0"; + default: + gcc_unreachable (); + } +@@ -4540,12 +4685,14 @@ loongarch_output_move (rtx dest, rtx src) + if (insn) + return insn; + +- if (lsx_p) ++ if (lsx_p || lasx_p) + { + switch (GET_MODE_SIZE (mode)) + { + case 16: + return "vst\t%w1,%0"; ++ case 32: ++ return "xvst\t%u1,%0"; + default: + gcc_unreachable (); + } +@@ -4566,12 +4713,14 @@ loongarch_output_move (rtx dest, rtx src) + if (insn) + return insn; + +- if (lsx_p) ++ if (lsx_p || lasx_p) + { + switch (GET_MODE_SIZE (mode)) + { + case 16: + return "vld\t%w0,%1"; ++ case 32: ++ return "xvld\t%u0,%1"; + default: + gcc_unreachable (); + } +@@ -5599,18 +5748,27 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part, + 'T' Print 'f' for (eq:CC ...), 't' for (ne:CC ...), + 'z' for (eq:?I ...), 'n' for (ne:?I ...). + 't' Like 'T', but with the EQ/NE cases reversed +- 'V' Print exact log2 of CONST_INT OP element 0 of a replicated +- CONST_VECTOR in decimal. ++ 'F' Print the FPU branch condition for comparison OP. ++ 'W' Print the inverse of the FPU branch condition for comparison OP. ++ 'w' Print a LSX register. ++ 'u' Print a LASX register. ++ 'T' Print 'f' for (eq:CC ...), 't' for (ne:CC ...), ++ 'z' for (eq:?I ...), 'n' for (ne:?I ...). ++ 't' Like 'T', but with the EQ/NE cases reversed ++ 'Y' Print loongarch_fp_conditionsINTVAL (OP) ++ 'Z' Print OP and a comma for 8CC, otherwise print nothing. ++ 'z' Print $0 if OP is zero, otherwise print OP normally. + 'v' Print the insn size suffix b, h, w or d for vector modes V16QI, V8HI, + V4SI, V2SI, and w, d for vector modes V4SF, V2DF respectively. ++ 'V' Print exact log2 of CONST_INT OP element 0 of a replicated ++ CONST_VECTOR in decimal. + 'W' Print the inverse of the FPU branch condition for comparison OP. +- 'w' Print a LSX register. + 'X' Print CONST_INT OP in hexadecimal format. + 'x' Print the low 16 bits of CONST_INT OP in hexadecimal format. + 'Y' Print loongarch_fp_conditionsINTVAL (OP) + 'y' Print exact log2 of CONST_INT OP in decimal. + 'Z' Print OP and a comma for 8CC, otherwise print nothing. +- 'z' Print $r0 if OP is zero, otherwise print OP normally. */ ++ 'z' Print $0 if OP is zero, otherwise print OP normally. */ + + static void + loongarch_print_operand (FILE *file, rtx op, int letter) +@@ -5752,46 +5910,11 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + output_operand_lossage ("invalid use of '%%%c'", letter); + break; + +- case 'v': +- switch (GET_MODE (op)) +- { +- case E_V16QImode: +- case E_V32QImode: +- fprintf (file, "b"); +- break; +- case E_V8HImode: +- case E_V16HImode: +- fprintf (file, "h"); +- break; +- case E_V4SImode: +- case E_V4SFmode: +- case E_V8SImode: +- case E_V8SFmode: +- fprintf (file, "w"); +- break; +- case E_V2DImode: +- case E_V2DFmode: +- case E_V4DImode: +- case E_V4DFmode: +- fprintf (file, "d"); +- break; +- default: +- output_operand_lossage ("invalid use of '%%%c'", letter); +- } +- break; +- + case 'W': + loongarch_print_float_branch_condition (file, reverse_condition (code), + letter); + break; + +- case 'w': +- if (code == REG && LSX_REG_P (REGNO (op))) +- fprintf (file, "$vr%s", ®_namesREGNO (op)2); +- else +- output_operand_lossage ("invalid use of '%%%c'", letter); +- break; +- + case 'x': + if (CONST_INT_P (op)) + fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (op) & 0xffff); +@@ -5833,6 +5956,48 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + fputc (',', file); + break; + ++ case 'w': ++ if (code == REG && LSX_REG_P (REGNO (op))) ++ fprintf (file, "$vr%s", ®_namesREGNO (op)2); ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ break; ++ ++ case 'u': ++ if (code == REG && LASX_REG_P (REGNO (op))) ++ fprintf (file, "$xr%s", ®_namesREGNO (op)2); ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ break; ++ ++ case 'v': ++ switch (GET_MODE (op)) ++ { ++ case E_V16QImode: ++ case E_V32QImode: ++ fprintf (file, "b"); ++ break; ++ case E_V8HImode: ++ case E_V16HImode: ++ fprintf (file, "h"); ++ break; ++ case E_V4SImode: ++ case E_V4SFmode: ++ case E_V8SImode: ++ case E_V8SFmode: ++ fprintf (file, "w"); ++ break; ++ case E_V2DImode: ++ case E_V2DFmode: ++ case E_V4DImode: ++ case E_V4DFmode: ++ fprintf (file, "d"); ++ break; ++ default: ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ } ++ break; ++ + default: + switch (code) + { +@@ -6163,13 +6328,18 @@ loongarch_hard_regno_mode_ok_uncached (unsigned int regno, machine_mode mode) + size = GET_MODE_SIZE (mode); + mclass = GET_MODE_CLASS (mode); + +- if (GP_REG_P (regno) && !LSX_SUPPORTED_MODE_P (mode)) ++ if (GP_REG_P (regno) && !LSX_SUPPORTED_MODE_P (mode) ++ && !LASX_SUPPORTED_MODE_P (mode)) + return ((regno - GP_REG_FIRST) & 1) == 0 || size <= UNITS_PER_WORD; + + /* For LSX, allow TImode and 128-bit vector modes in all FPR. */ + if (FP_REG_P (regno) && LSX_SUPPORTED_MODE_P (mode)) + return true; + ++ /* FIXED ME: For LASX, allow TImode and 256-bit vector modes in all FPR. */ ++ if (FP_REG_P (regno) && LASX_SUPPORTED_MODE_P (mode)) ++ return true; ++ + if (FP_REG_P (regno)) + { + if (mclass == MODE_FLOAT +@@ -6222,6 +6392,9 @@ loongarch_hard_regno_nregs (unsigned int regno, machine_mode mode) + if (LSX_SUPPORTED_MODE_P (mode)) + return 1; + ++ if (LASX_SUPPORTED_MODE_P (mode)) ++ return 1; ++ + return (GET_MODE_SIZE (mode) + UNITS_PER_FPREG - 1) / UNITS_PER_FPREG; + } + +@@ -6251,7 +6424,10 @@ loongarch_class_max_nregs (enum reg_class rclass, machine_mode mode) + { + if (loongarch_hard_regno_mode_ok (FP_REG_FIRST, mode)) + { +- if (LSX_SUPPORTED_MODE_P (mode)) ++ /* Fixed me. */ ++ if (LASX_SUPPORTED_MODE_P (mode)) ++ size = MIN (size, UNITS_PER_LASX_REG); ++ else if (LSX_SUPPORTED_MODE_P (mode)) + size = MIN (size, UNITS_PER_LSX_REG); + else + size = MIN (size, UNITS_PER_FPREG); +@@ -6269,6 +6445,10 @@ static bool + loongarch_can_change_mode_class (machine_mode from, machine_mode to, + reg_class_t rclass) + { ++ /* Allow conversions between different LSX/LASX vector modes. */ ++ if (LASX_SUPPORTED_MODE_P (from) && LASX_SUPPORTED_MODE_P (to)) ++ return true; ++ + /* Allow conversions between different LSX vector modes. */ + if (LSX_SUPPORTED_MODE_P (from) && LSX_SUPPORTED_MODE_P (to)) + return true; +@@ -6292,7 +6472,8 @@ loongarch_mode_ok_for_mov_fmt_p (machine_mode mode) + return TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT; + + default: +- return LSX_SUPPORTED_MODE_P (mode); ++ return ISA_HAS_LASX ? LASX_SUPPORTED_MODE_P (mode) ++ : LSX_SUPPORTED_MODE_P (mode); + } + } + +@@ -6494,7 +6675,8 @@ loongarch_valid_pointer_mode (scalar_int_mode mode) + static bool + loongarch_vector_mode_supported_p (machine_mode mode) + { +- return LSX_SUPPORTED_MODE_P (mode); ++ return ISA_HAS_LASX ? LASX_SUPPORTED_MODE_P (mode) ++ : LSX_SUPPORTED_MODE_P (mode); + } + + /* Implement TARGET_SCALAR_MODE_SUPPORTED_P. */ +@@ -6520,19 +6702,19 @@ loongarch_preferred_simd_mode (scalar_mode mode) + switch (mode) + { + case E_QImode: +- return E_V16QImode; ++ return ISA_HAS_LASX ? E_V32QImode : E_V16QImode; + case E_HImode: +- return E_V8HImode; ++ return ISA_HAS_LASX ? E_V16HImode : E_V8HImode; + case E_SImode: +- return E_V4SImode; ++ return ISA_HAS_LASX ? E_V8SImode : E_V4SImode; + case E_DImode: +- return E_V2DImode; ++ return ISA_HAS_LASX ? E_V4DImode : E_V2DImode; + + case E_SFmode: +- return E_V4SFmode; ++ return ISA_HAS_LASX ? E_V8SFmode : E_V4SFmode; + + case E_DFmode: +- return E_V2DFmode; ++ return ISA_HAS_LASX ? E_V4DFmode : E_V2DFmode; + + default: + break; +@@ -6543,7 +6725,12 @@ loongarch_preferred_simd_mode (scalar_mode mode) + static unsigned int + loongarch_autovectorize_vector_modes (vector_modes *modes, bool) + { +- if (ISA_HAS_LSX) ++ if (ISA_HAS_LASX) ++ { ++ modes->safe_push (V32QImode); ++ modes->safe_push (V16QImode); ++ } ++ else if (ISA_HAS_LSX) + { + modes->safe_push (V16QImode); + } +@@ -6723,11 +6910,18 @@ const char * + loongarch_lsx_output_division (const char *division, rtx *operands) + { + const char *s; ++ machine_mode mode = GET_MODE (*operands); + + s = division; + if (TARGET_CHECK_ZERO_DIV) + { +- if (ISA_HAS_LSX) ++ if (ISA_HAS_LASX && GET_MODE_SIZE (mode) == 32) ++ { ++ output_asm_insn ("xvsetallnez.%v0\t$fcc7,%u2",operands); ++ output_asm_insn (s, operands); ++ output_asm_insn ("bcnez\t$fcc7,1f", operands); ++ } ++ else if (ISA_HAS_LSX) + { + output_asm_insn ("vsetallnez.%v0\t$fcc7,%w2",operands); + output_asm_insn (s, operands); +@@ -7566,7 +7760,7 @@ loongarch_expand_lsx_shuffle (struct expand_vec_perm_d *d) + rtx_insn *insn; + unsigned i; + +- if (!ISA_HAS_LSX) ++ if (!ISA_HAS_LSX && !ISA_HAS_LASX) + return false; + + for (i = 0; i < d->nelt; i++) +@@ -7590,40 +7784,484 @@ loongarch_expand_lsx_shuffle (struct expand_vec_perm_d *d) + return true; + } + +-void +-loongarch_expand_vec_perm (rtx target, rtx op0, rtx op1, rtx sel) ++/* Try to simplify a two vector permutation using 2 intra-lane interleave ++ insns and cross-lane shuffle for 32-byte vectors. */ ++ ++static bool ++loongarch_expand_vec_perm_interleave (struct expand_vec_perm_d *d) + { +- machine_mode vmode = GET_MODE (target); ++ unsigned i, nelt; ++ rtx t1,t2,t3; ++ rtx (*gen_high) (rtx, rtx, rtx); ++ rtx (*gen_low) (rtx, rtx, rtx); ++ machine_mode mode = GET_MODE (d->target); + +- switch (vmode) ++ if (d->one_vector_p) ++ return false; ++ if (ISA_HAS_LASX && GET_MODE_SIZE (d->vmode) == 32) ++ ; ++ else ++ return false; ++ ++ nelt = d->nelt; ++ if (d->perm0 != 0 && d->perm0 != nelt / 2) ++ return false; ++ for (i = 0; i < nelt; i += 2) ++ if (d->permi != d->perm0 + i / 2 ++ || d->permi + 1 != d->perm0 + i / 2 + nelt) ++ return false; ++ ++ if (d->testing_p) ++ return true; ++ ++ switch (d->vmode) + { +- case E_V16QImode: +- emit_insn (gen_lsx_vshuf_b (target, op1, op0, sel)); ++ case E_V32QImode: ++ gen_high = gen_lasx_xvilvh_b; ++ gen_low = gen_lasx_xvilvl_b; + break; +- case E_V2DFmode: +- emit_insn (gen_lsx_vshuf_d_f (target, sel, op1, op0)); ++ case E_V16HImode: ++ gen_high = gen_lasx_xvilvh_h; ++ gen_low = gen_lasx_xvilvl_h; + break; +- case E_V2DImode: +- emit_insn (gen_lsx_vshuf_d (target, sel, op1, op0)); ++ case E_V8SImode: ++ gen_high = gen_lasx_xvilvh_w; ++ gen_low = gen_lasx_xvilvl_w; + break; +- case E_V4SFmode: +- emit_insn (gen_lsx_vshuf_w_f (target, sel, op1, op0)); ++ case E_V4DImode: ++ gen_high = gen_lasx_xvilvh_d; ++ gen_low = gen_lasx_xvilvl_d; + break; +- case E_V4SImode: +- emit_insn (gen_lsx_vshuf_w (target, sel, op1, op0)); ++ case E_V8SFmode: ++ gen_high = gen_lasx_xvilvh_w_f; ++ gen_low = gen_lasx_xvilvl_w_f; + break; +- case E_V8HImode: +- emit_insn (gen_lsx_vshuf_h (target, sel, op1, op0)); ++ case E_V4DFmode: ++ gen_high = gen_lasx_xvilvh_d_f; ++ gen_low = gen_lasx_xvilvl_d_f; + break; + default: +- break; ++ gcc_unreachable (); ++ } ++ ++ t1 = gen_reg_rtx (mode); ++ t2 = gen_reg_rtx (mode); ++ emit_insn (gen_high (t1, d->op0, d->op1)); ++ emit_insn (gen_low (t2, d->op0, d->op1)); ++ if (mode == V4DFmode || mode == V8SFmode) ++ { ++ t3 = gen_reg_rtx (V4DFmode); ++ if (d->perm0) ++ emit_insn (gen_lasx_xvpermi_q_v4df (t3, gen_lowpart (V4DFmode, t1), ++ gen_lowpart (V4DFmode, t2), ++ GEN_INT (0x31))); ++ else ++ emit_insn (gen_lasx_xvpermi_q_v4df (t3, gen_lowpart (V4DFmode, t1), ++ gen_lowpart (V4DFmode, t2), ++ GEN_INT (0x20))); + } ++ else ++ { ++ t3 = gen_reg_rtx (V4DImode); ++ if (d->perm0) ++ emit_insn (gen_lasx_xvpermi_q_v4di (t3, gen_lowpart (V4DImode, t1), ++ gen_lowpart (V4DImode, t2), ++ GEN_INT (0x31))); ++ else ++ emit_insn (gen_lasx_xvpermi_q_v4di (t3, gen_lowpart (V4DImode, t1), ++ gen_lowpart (V4DImode, t2), ++ GEN_INT (0x20))); ++ } ++ emit_move_insn (d->target, gen_lowpart (mode, t3)); ++ return true; + } + ++/* Implement extract-even and extract-odd permutations. */ ++ + static bool +-loongarch_try_expand_lsx_vshuf_const (struct expand_vec_perm_d *d) ++loongarch_expand_vec_perm_even_odd_1 (struct expand_vec_perm_d *d, unsigned odd) + { +- int i; ++ rtx t1; ++ machine_mode mode = GET_MODE (d->target); ++ ++ if (d->testing_p) ++ return true; ++ ++ t1 = gen_reg_rtx (mode); ++ ++ switch (d->vmode) ++ { ++ case E_V4DFmode: ++ /* Shuffle the lanes around into { 0 4 2 6 } and { 1 5 3 7 }. */ ++ if (odd) ++ emit_insn (gen_lasx_xvilvh_d_f (t1, d->op0, d->op1)); ++ else ++ emit_insn (gen_lasx_xvilvl_d_f (t1, d->op0, d->op1)); ++ ++ /* Shuffle within the 256-bit lanes to produce the result required. ++ { 0 2 4 6 } | { 1 3 5 7 }. */ ++ emit_insn (gen_lasx_xvpermi_d_v4df (d->target, t1, GEN_INT (0xd8))); ++ break; ++ ++ case E_V4DImode: ++ if (odd) ++ emit_insn (gen_lasx_xvilvh_d (t1, d->op0, d->op1)); ++ else ++ emit_insn (gen_lasx_xvilvl_d (t1, d->op0, d->op1)); ++ ++ emit_insn (gen_lasx_xvpermi_d_v4di (d->target, t1, GEN_INT (0xd8))); ++ break; ++ ++ case E_V8SFmode: ++ /* Shuffle the lanes around into: ++ { 0 2 8 a 4 6 c e } | { 1 3 9 b 5 7 d f }. */ ++ if (odd) ++ emit_insn (gen_lasx_xvpickod_w_f (t1, d->op0, d->op1)); ++ else ++ emit_insn (gen_lasx_xvpickev_w_f (t1, d->op0, d->op1)); ++ ++ /* Shuffle within the 256-bit lanes to produce the result required. ++ { 0 2 4 6 8 a c e } | { 1 3 5 7 9 b d f }. */ ++ emit_insn (gen_lasx_xvpermi_d_v8sf (d->target, t1, GEN_INT (0xd8))); ++ break; ++ ++ case E_V8SImode: ++ if (odd) ++ emit_insn (gen_lasx_xvpickod_w (t1, d->op0, d->op1)); ++ else ++ emit_insn (gen_lasx_xvpickev_w (t1, d->op0, d->op1)); ++ ++ emit_insn (gen_lasx_xvpermi_d_v8si (d->target, t1, GEN_INT (0xd8))); ++ break; ++ ++ case E_V16HImode: ++ if (odd) ++ emit_insn (gen_lasx_xvpickod_h (t1, d->op0, d->op1)); ++ else ++ emit_insn (gen_lasx_xvpickev_h (t1, d->op0, d->op1)); ++ ++ emit_insn (gen_lasx_xvpermi_d_v16hi (d->target, t1, GEN_INT (0xd8))); ++ break; ++ ++ case E_V32QImode: ++ if (odd) ++ emit_insn (gen_lasx_xvpickod_b (t1, d->op0, d->op1)); ++ else ++ emit_insn (gen_lasx_xvpickev_b (t1, d->op0, d->op1)); ++ ++ emit_insn (gen_lasx_xvpermi_d_v32qi (d->target, t1, GEN_INT (0xd8))); ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ ++ return true; ++} ++ ++/* Pattern match extract-even and extract-odd permutations. */ ++ ++static bool ++loongarch_expand_vec_perm_even_odd (struct expand_vec_perm_d *d) ++{ ++ unsigned i, odd, nelt = d->nelt; ++ if (!ISA_HAS_LASX) ++ return false; ++ ++ odd = d->perm0; ++ if (odd != 0 && odd != 1) ++ return false; ++ ++ for (i = 1; i < nelt; ++i) ++ if (d->permi != 2 * i + odd) ++ return false; ++ ++ return loongarch_expand_vec_perm_even_odd_1 (d, odd); ++} ++ ++/* Expand a variable vector permutation for LASX. */ ++ ++void ++loongarch_expand_vec_perm_1 (rtx operands) ++{ ++ rtx target = operands0; ++ rtx op0 = operands1; ++ rtx op1 = operands2; ++ rtx mask = operands3; ++ ++ bool one_operand_shuffle = rtx_equal_p (op0, op1); ++ rtx t1 = NULL; ++ rtx t2 = NULL; ++ rtx t3, t4, t5, t6, vt = NULL; ++ rtx vec32 = {NULL}; ++ machine_mode mode = GET_MODE (op0); ++ machine_mode maskmode = GET_MODE (mask); ++ int w, i; ++ ++ /* Number of elements in the vector. */ ++ w = GET_MODE_NUNITS (mode); ++ ++ rtx round_dataMAX_VECT_LEN; ++ rtx round_reg, round_data_rtx; ++ ++ if (mode != E_V32QImode) ++ { ++ for (int i = 0; i < w; i += 1) ++ { ++ round_datai = GEN_INT (0x1f); ++ } ++ ++ if (mode == E_V4DFmode) ++ { ++ round_data_rtx = gen_rtx_CONST_VECTOR (E_V4DImode, ++ gen_rtvec_v (w, round_data)); ++ round_reg = gen_reg_rtx (E_V4DImode); ++ } ++ else if (mode == E_V8SFmode) ++ { ++ ++ round_data_rtx = gen_rtx_CONST_VECTOR (E_V8SImode, ++ gen_rtvec_v (w, round_data)); ++ round_reg = gen_reg_rtx (E_V8SImode); ++ } ++ else ++ { ++ round_data_rtx = gen_rtx_CONST_VECTOR (mode, ++ gen_rtvec_v (w, round_data)); ++ round_reg = gen_reg_rtx (mode); ++ } ++ ++ emit_move_insn (round_reg, round_data_rtx); ++ switch (mode) ++ { ++ case E_V32QImode: ++ emit_insn (gen_andv32qi3 (mask, mask, round_reg)); ++ break; ++ case E_V16HImode: ++ emit_insn (gen_andv16hi3 (mask, mask, round_reg)); ++ break; ++ case E_V8SImode: ++ case E_V8SFmode: ++ emit_insn (gen_andv8si3 (mask, mask, round_reg)); ++ break; ++ case E_V4DImode: ++ case E_V4DFmode: ++ emit_insn (gen_andv4di3 (mask, mask, round_reg)); ++ break; ++ default: ++ gcc_unreachable (); ++ break; ++ } ++ } ++ ++ if (mode == V4DImode || mode == V4DFmode) ++ { ++ maskmode = mode = V8SImode; ++ w = 8; ++ t1 = gen_reg_rtx (maskmode); ++ ++ /* Replicate the low bits of the V4DImode mask into V8SImode: ++ mask = { A B C D } ++ t1 = { A A B B C C D D }. */ ++ for (i = 0; i < w / 2; ++i) ++ veci*2 + 1 = veci*2 = GEN_INT (i * 2); ++ vt = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec)); ++ vt = force_reg (maskmode, vt); ++ mask = gen_lowpart (maskmode, mask); ++ emit_insn (gen_lasx_xvperm_w (t1, mask, vt)); ++ ++ /* Multiply the shuffle indicies by two. */ ++ t1 = expand_simple_binop (maskmode, PLUS, t1, t1, t1, 1, ++ OPTAB_DIRECT); ++ ++ /* Add one to the odd shuffle indicies: ++ t1 = { A*2, A*2+1, B*2, B*2+1, ... }. */ ++ for (i = 0; i < w / 2; ++i) ++ { ++ veci * 2 = const0_rtx; ++ veci * 2 + 1 = const1_rtx; ++ } ++ vt = gen_rtx_CONST_VECTOR (maskmode, gen_rtvec_v (w, vec)); ++ vt = validize_mem (force_const_mem (maskmode, vt)); ++ t1 = expand_simple_binop (maskmode, PLUS, t1, vt, t1, 1, ++ OPTAB_DIRECT); ++ ++ /* Continue as if V8SImode (resp. V32QImode) was used initially. */ ++ operands3 = mask = t1; ++ target = gen_reg_rtx (mode); ++ op0 = gen_lowpart (mode, op0); ++ op1 = gen_lowpart (mode, op1); ++ } ++ ++ switch (mode) ++ { ++ case E_V8SImode: ++ if (one_operand_shuffle) ++ { ++ emit_insn (gen_lasx_xvperm_w (target, op0, mask)); ++ if (target != operands0) ++ emit_move_insn (operands0, ++ gen_lowpart (GET_MODE (operands0), target)); ++ } ++ else ++ { ++ t1 = gen_reg_rtx (V8SImode); ++ t2 = gen_reg_rtx (V8SImode); ++ emit_insn (gen_lasx_xvperm_w (t1, op0, mask)); ++ emit_insn (gen_lasx_xvperm_w (t2, op1, mask)); ++ goto merge_two; ++ } ++ return; ++ ++ case E_V8SFmode: ++ mask = gen_lowpart (V8SImode, mask); ++ if (one_operand_shuffle) ++ emit_insn (gen_lasx_xvperm_w_f (target, op0, mask)); ++ else ++ { ++ t1 = gen_reg_rtx (V8SFmode); ++ t2 = gen_reg_rtx (V8SFmode); ++ emit_insn (gen_lasx_xvperm_w_f (t1, op0, mask)); ++ emit_insn (gen_lasx_xvperm_w_f (t2, op1, mask)); ++ goto merge_two; ++ } ++ return; ++ ++ case E_V16HImode: ++ if (one_operand_shuffle) ++ { ++ t1 = gen_reg_rtx (V16HImode); ++ t2 = gen_reg_rtx (V16HImode); ++ emit_insn (gen_lasx_xvpermi_d_v16hi (t1, op0, GEN_INT (0x44))); ++ emit_insn (gen_lasx_xvpermi_d_v16hi (t2, op0, GEN_INT (0xee))); ++ emit_insn (gen_lasx_xvshuf_h (target, mask, t2, t1)); ++ } ++ else ++ { ++ t1 = gen_reg_rtx (V16HImode); ++ t2 = gen_reg_rtx (V16HImode); ++ t3 = gen_reg_rtx (V16HImode); ++ t4 = gen_reg_rtx (V16HImode); ++ t5 = gen_reg_rtx (V16HImode); ++ t6 = gen_reg_rtx (V16HImode); ++ emit_insn (gen_lasx_xvpermi_d_v16hi (t3, op0, GEN_INT (0x44))); ++ emit_insn (gen_lasx_xvpermi_d_v16hi (t4, op0, GEN_INT (0xee))); ++ emit_insn (gen_lasx_xvshuf_h (t1, mask, t4, t3)); ++ emit_insn (gen_lasx_xvpermi_d_v16hi (t5, op1, GEN_INT (0x44))); ++ emit_insn (gen_lasx_xvpermi_d_v16hi (t6, op1, GEN_INT (0xee))); ++ emit_insn (gen_lasx_xvshuf_h (t2, mask, t6, t5)); ++ goto merge_two; ++ } ++ return; ++ ++ case E_V32QImode: ++ if (one_operand_shuffle) ++ { ++ t1 = gen_reg_rtx (V32QImode); ++ t2 = gen_reg_rtx (V32QImode); ++ emit_insn (gen_lasx_xvpermi_d_v32qi (t1, op0, GEN_INT (0x44))); ++ emit_insn (gen_lasx_xvpermi_d_v32qi (t2, op0, GEN_INT (0xee))); ++ emit_insn (gen_lasx_xvshuf_b (target, t2, t1, mask)); ++ } ++ else ++ { ++ t1 = gen_reg_rtx (V32QImode); ++ t2 = gen_reg_rtx (V32QImode); ++ t3 = gen_reg_rtx (V32QImode); ++ t4 = gen_reg_rtx (V32QImode); ++ t5 = gen_reg_rtx (V32QImode); ++ t6 = gen_reg_rtx (V32QImode); ++ emit_insn (gen_lasx_xvpermi_d_v32qi (t3, op0, GEN_INT (0x44))); ++ emit_insn (gen_lasx_xvpermi_d_v32qi (t4, op0, GEN_INT (0xee))); ++ emit_insn (gen_lasx_xvshuf_b (t1, t4, t3, mask)); ++ emit_insn (gen_lasx_xvpermi_d_v32qi (t5, op1, GEN_INT (0x44))); ++ emit_insn (gen_lasx_xvpermi_d_v32qi (t6, op1, GEN_INT (0xee))); ++ emit_insn (gen_lasx_xvshuf_b (t2, t6, t5, mask)); ++ goto merge_two; ++ } ++ return; ++ ++ default: ++ gcc_assert (GET_MODE_SIZE (mode) == 32); ++ break; ++ } ++ ++merge_two: ++ /* Then merge them together. The key is whether any given control ++ element contained a bit set that indicates the second word. */ ++ rtx xops6; ++ mask = operands3; ++ vt = GEN_INT (w); ++ vt = gen_const_vec_duplicate (maskmode, vt); ++ vt = force_reg (maskmode, vt); ++ mask = expand_simple_binop (maskmode, AND, mask, vt, ++ NULL_RTX, 0, OPTAB_DIRECT); ++ if (GET_MODE (target) != mode) ++ target = gen_reg_rtx (mode); ++ xops0 = target; ++ xops1 = gen_lowpart (mode, t2); ++ xops2 = gen_lowpart (mode, t1); ++ xops3 = gen_rtx_EQ (maskmode, mask, vt); ++ xops4 = mask; ++ xops5 = vt; ++ ++ loongarch_expand_vec_cond_expr (mode, maskmode, xops); ++ if (target != operands0) ++ emit_move_insn (operands0, ++ gen_lowpart (GET_MODE (operands0), target)); ++} ++ ++void ++loongarch_expand_vec_perm (rtx target, rtx op0, rtx op1, rtx sel) ++{ ++ machine_mode vmode = GET_MODE (target); ++ auto nelt = GET_MODE_NUNITS (vmode); ++ auto round_reg = gen_reg_rtx (vmode); ++ rtx round_dataMAX_VECT_LEN; ++ ++ for (int i = 0; i < nelt; i += 1) ++ { ++ round_datai = GEN_INT (0x1f); ++ } ++ ++ rtx round_data_rtx = gen_rtx_CONST_VECTOR (vmode, gen_rtvec_v (nelt, round_data)); ++ emit_move_insn (round_reg, round_data_rtx); ++ ++ switch (vmode) ++ { ++ case E_V16QImode: ++ emit_insn (gen_andv16qi3 (sel, sel, round_reg)); ++ emit_insn (gen_lsx_vshuf_b (target, op1, op0, sel)); ++ break; ++ case E_V2DFmode: ++ emit_insn (gen_andv2di3 (sel, sel, round_reg)); ++ emit_insn (gen_lsx_vshuf_d_f (target, sel, op1, op0)); ++ break; ++ case E_V2DImode: ++ emit_insn (gen_andv2di3 (sel, sel, round_reg)); ++ emit_insn (gen_lsx_vshuf_d (target, sel, op1, op0)); ++ break; ++ case E_V4SFmode: ++ emit_insn (gen_andv4si3 (sel, sel, round_reg)); ++ emit_insn (gen_lsx_vshuf_w_f (target, sel, op1, op0)); ++ break; ++ case E_V4SImode: ++ emit_insn (gen_andv4si3 (sel, sel, round_reg)); ++ emit_insn (gen_lsx_vshuf_w (target, sel, op1, op0)); ++ break; ++ case E_V8HImode: ++ emit_insn (gen_andv8hi3 (sel, sel, round_reg)); ++ emit_insn (gen_lsx_vshuf_h (target, sel, op1, op0)); ++ break; ++ default: ++ break; ++ } ++} ++ ++static bool ++loongarch_try_expand_lsx_vshuf_const (struct expand_vec_perm_d *d) ++{ ++ int i; + rtx target, op0, op1, sel, tmp; + rtx rpermMAX_VECT_LEN; + +@@ -7724,25 +8362,1302 @@ loongarch_expand_vec_perm_const_1 (struct expand_vec_perm_d *d) + return true; + } + +- if (loongarch_expand_lsx_shuffle (d)) +- return true; +- return false; +-} +- +-/* Implementation of constant vector permuatation. This function identifies +- * recognized pattern of permuation selector argument, and use one or more +- * instruction(s) to finish the permutation job correctly. For unsupported +- * patterns, it will return false. */ +- +-static bool +-loongarch_expand_vec_perm_const_2 (struct expand_vec_perm_d *d) +-{ +- /* Although we have the LSX vec_perm<mode> template, there's still some +- 128bit vector permuatation operations send to vectorize_vec_perm_const. +- In this case, we just simpliy wrap them by single vshuf.* instruction, +- because LSX vshuf.* instruction just have the same behavior that GCC +- expects. */ +- return loongarch_try_expand_lsx_vshuf_const (d); ++ if (loongarch_expand_lsx_shuffle (d)) ++ return true; ++ if (loongarch_expand_vec_perm_even_odd (d)) ++ return true; ++ if (loongarch_expand_vec_perm_interleave (d)) ++ return true; ++ return false; ++} ++ ++/* Following are the assist function for const vector permutation support. */ ++static bool ++loongarch_is_quad_duplicate (struct expand_vec_perm_d *d) ++{ ++ if (d->perm0 >= d->nelt / 2) ++ return false; ++ ++ bool result = true; ++ unsigned char lhs = d->perm0; ++ unsigned char rhs = d->permd->nelt / 2; ++ ++ if ((rhs - lhs) != d->nelt / 2) ++ return false; ++ ++ for (int i = 1; i < d->nelt; i += 1) ++ { ++ if ((i < d->nelt / 2) && (d->permi != lhs)) ++ { ++ result = false; ++ break; ++ } ++ if ((i > d->nelt / 2) && (d->permi != rhs)) ++ { ++ result = false; ++ break; ++ } ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_double_duplicate (struct expand_vec_perm_d *d) ++{ ++ if (!d->one_vector_p) ++ return false; ++ ++ if (d->nelt < 8) ++ return false; ++ ++ bool result = true; ++ unsigned char buf = d->perm0; ++ ++ for (int i = 1; i < d->nelt; i += 2) ++ { ++ if (d->permi != buf) ++ { ++ result = false; ++ break; ++ } ++ if (d->permi - 1 != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += d->nelt / 4; ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_odd_extraction (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned char buf = 1; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 2; ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_even_extraction (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned char buf = 0; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_extraction_permutation (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned char buf = d->perm0; ++ ++ if (buf != 0 || buf != d->nelt) ++ return false; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 2; ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_center_extraction (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned buf = d->nelt / 2; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_reversing_permutation (struct expand_vec_perm_d *d) ++{ ++ if (!d->one_vector_p) ++ return false; ++ ++ bool result = true; ++ unsigned char buf = d->nelt - 1; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (d->permi != buf) ++ { ++ result = false; ++ break; ++ } ++ ++ buf -= 1; ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_di_misalign_extract (struct expand_vec_perm_d *d) ++{ ++ if (d->nelt != 4 && d->nelt != 8) ++ return false; ++ ++ bool result = true; ++ unsigned char buf; ++ ++ if (d->nelt == 4) ++ { ++ buf = 1; ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ ++ buf += 1; ++ } ++ } ++ else if (d->nelt == 8) ++ { ++ buf = 2; ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ ++ buf += 1; ++ } ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_si_misalign_extract (struct expand_vec_perm_d *d) ++{ ++ if (d->vmode != E_V8SImode && d->vmode != E_V8SFmode) ++ return false; ++ bool result = true; ++ unsigned char buf = 1; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_lasx_lowpart_interleave (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned char buf = 0; ++ ++ for (int i = 0;i < d->nelt; i += 2) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ ++ if (result) ++ { ++ buf = d->nelt; ++ for (int i = 1; i < d->nelt; i += 2) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_lasx_lowpart_interleave_2 (struct expand_vec_perm_d *d) ++{ ++ if (d->vmode != E_V32QImode) ++ return false; ++ bool result = true; ++ unsigned char buf = 0; ++ ++#define COMPARE_SELECTOR(INIT, BEGIN, END) \ ++ buf = INIT; \ ++ for (int i = BEGIN; i < END && result; i += 1) \ ++ { \ ++ if (buf != d->permi) \ ++ { \ ++ result = false; \ ++ break; \ ++ } \ ++ buf += 1; \ ++ } ++ ++ COMPARE_SELECTOR (0, 0, 8); ++ COMPARE_SELECTOR (32, 8, 16); ++ COMPARE_SELECTOR (8, 16, 24); ++ COMPARE_SELECTOR (40, 24, 32); ++ ++#undef COMPARE_SELECTOR ++ return result; ++} ++ ++static bool ++loongarch_is_lasx_lowpart_extract (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned char buf = 0; ++ ++ for (int i = 0; i < d->nelt / 2; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ ++ if (result) ++ { ++ buf = d->nelt; ++ for (int i = d->nelt / 2; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_lasx_highpart_interleave (expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned char buf = d->nelt / 2; ++ ++ for (int i = 0; i < d->nelt; i += 2) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ ++ if (result) ++ { ++ buf = d->nelt + d->nelt / 2; ++ for (int i = 1; i < d->nelt;i += 2) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ buf += 1; ++ } ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_lasx_highpart_interleave_2 (struct expand_vec_perm_d *d) ++{ ++ if (d->vmode != E_V32QImode) ++ return false; ++ ++ bool result = true; ++ unsigned char buf = 0; ++ ++#define COMPARE_SELECTOR(INIT, BEGIN, END) \ ++ buf = INIT; \ ++ for (int i = BEGIN; i < END && result; i += 1) \ ++ { \ ++ if (buf != d->permi) \ ++ { \ ++ result = false; \ ++ break; \ ++ } \ ++ buf += 1; \ ++ } ++ ++ COMPARE_SELECTOR (16, 0, 8); ++ COMPARE_SELECTOR (48, 8, 16); ++ COMPARE_SELECTOR (24, 16, 24); ++ COMPARE_SELECTOR (56, 24, 32); ++ ++#undef COMPARE_SELECTOR ++ return result; ++} ++ ++static bool ++loongarch_is_elem_duplicate (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ unsigned char buf = d->perm0; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (buf != d->permi) ++ { ++ result = false; ++ break; ++ } ++ } ++ ++ return result; ++} ++ ++inline bool ++loongarch_is_op_reverse_perm (struct expand_vec_perm_d *d) ++{ ++ return (d->vmode == E_V4DFmode) ++ && d->perm0 == 2 && d->perm1 == 3 ++ && d->perm2 == 0 && d->perm3 == 1; ++} ++ ++static bool ++loongarch_is_single_op_perm (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ ++ for (int i = 0; i < d->nelt; i += 1) ++ { ++ if (d->permi >= d->nelt) ++ { ++ result = false; ++ break; ++ } ++ } ++ ++ return result; ++} ++ ++static bool ++loongarch_is_divisible_perm (struct expand_vec_perm_d *d) ++{ ++ bool result = true; ++ ++ for (int i = 0; i < d->nelt / 2; i += 1) ++ { ++ if (d->permi >= d->nelt) ++ { ++ result = false; ++ break; ++ } ++ } ++ ++ if (result) ++ { ++ for (int i = d->nelt / 2; i < d->nelt; i += 1) ++ { ++ if (d->permi < d->nelt) ++ { ++ result = false; ++ break; ++ } ++ } ++ } ++ ++ return result; ++} ++ ++inline bool ++loongarch_is_triple_stride_extract (struct expand_vec_perm_d *d) ++{ ++ return (d->vmode == E_V4DImode || d->vmode == E_V4DFmode) ++ && d->perm0 == 1 && d->perm1 == 4 ++ && d->perm2 == 7 && d->perm3 == 0; ++} ++ ++/* In LASX, some permutation insn does not have the behavior that gcc expects ++ * when compiler wants to emit a vector permutation. ++ * ++ * 1. What GCC provides via vectorize_vec_perm_const ()'s paramater: ++ * When GCC wants to performs a vector permutation, it provides two op ++ * reigster, one target register, and a selector. ++ * In const vector permutation case, GCC provides selector as a char array ++ * that contains original value; in variable vector permuatation ++ * (performs via vec_perm<mode> insn template), it provides a vector register. ++ * We assume that nelt is the elements numbers inside single vector in current ++ * 256bit vector mode. ++ * ++ * 2. What GCC expects to perform: ++ * Two op registers (op0, op1) will "combine" into a 512bit temp vector storage ++ * that has 2*nelt elements inside it; the low 256bit is op0, and high 256bit ++ * is op1, then the elements are indexed as below: ++ * 0 ~ nelt - 1 nelt ~ 2 * nelt - 1 ++ * |-------------------------|-------------------------| ++ * Low 256bit (op0) High 256bit (op1) ++ * For example, the second element in op1 (V8SImode) will be indexed with 9. ++ * Selector is a vector that has the same mode and number of elements with ++ * op0,op1 and target, it's look like this: ++ * 0 ~ nelt - 1 ++ * |-------------------------| ++ * 256bit (selector) ++ * It describes which element from 512bit temp vector storage will fit into ++ * target's every element slot. ++ * GCC expects that every element in selector can be ANY indices of 512bit ++ * vector storage (Selector can pick literally any element from op0 and op1, and ++ * then fits into any place of target register). This is also what LSX 128bit ++ * vshuf.* instruction do similarly, so we can handle 128bit vector permutation ++ * by single instruction easily. ++ * ++ * 3. What LASX permutation instruction does: ++ * In short, it just execute two independent 128bit vector permuatation, and ++ * it's the reason that we need to do the jobs below. We will explain it. ++ * op0, op1, target, and selector will be separate into high 128bit and low ++ * 128bit, and do permutation as the description below: ++ * ++ * a) op0's low 128bit and op1's low 128bit "combines" into a 256bit temp ++ * vector storage (TVS1), elements are indexed as below: ++ * 0 ~ nelt / 2 - 1 nelt / 2 ~ nelt - 1 ++ * |---------------------|---------------------| TVS1 ++ * op0's low 128bit op1's low 128bit ++ * op0's high 128bit and op1's high 128bit are "combined" into TVS2 in the ++ * same way. ++ * 0 ~ nelt / 2 - 1 nelt / 2 ~ nelt - 1 ++ * |---------------------|---------------------| TVS2 ++ * op0's high 128bit op1's high 128bit ++ * b) Selector's low 128bit describes which elements from TVS1 will fit into ++ * target vector's low 128bit. No TVS2 elements are allowed. ++ * c) Selector's high 128bit describes which elements from TVS2 will fit into ++ * target vector's high 128bit. No TVS1 elements are allowed. ++ * ++ * As we can see, if we want to handle vector permutation correctly, we can ++ * achieve it in three ways: ++ * a) Modify selector's elements, to make sure that every elements can inform ++ * correct value that will put into target vector. ++ b) Generate extra instruction before/after permutation instruction, for ++ adjusting op vector or target vector, to make sure target vector's value is ++ what GCC expects. ++ c) Use other instructions to process op and put correct result into target. ++ */ ++ ++/* Implementation of constant vector permuatation. This function identifies ++ * recognized pattern of permuation selector argument, and use one or more ++ * instruction(s) to finish the permutation job correctly. For unsupported ++ * patterns, it will return false. */ ++ ++static bool ++loongarch_expand_vec_perm_const_2 (struct expand_vec_perm_d *d) ++{ ++ /* Although we have the LSX vec_perm<mode> template, there's still some ++ 128bit vector permuatation operations send to vectorize_vec_perm_const. ++ In this case, we just simpliy wrap them by single vshuf.* instruction, ++ because LSX vshuf.* instruction just have the same behavior that GCC ++ expects. */ ++ if (GET_MODE_SIZE (d->vmode) == 16) ++ return loongarch_try_expand_lsx_vshuf_const (d); ++ else ++ return false; ++ ++ bool ok = false, reverse_hi_lo = false, extract_ev_od = false, ++ use_alt_op = false; ++ unsigned char idx; ++ int i; ++ rtx target, op0, op1, sel, tmp; ++ rtx op0_alt = NULL_RTX, op1_alt = NULL_RTX; ++ rtx rpermMAX_VECT_LEN; ++ unsigned int remappedMAX_VECT_LEN; ++ ++ /* Try to figure out whether is a recognized permutation selector pattern, if ++ yes, we will reassign some elements with new value in selector argument, ++ and in some cases we will generate some assist insn to complete the ++ permutation. (Even in some cases, we use other insn to impl permutation ++ instead of xvshuf!) ++ ++ Make sure to check d->testing_p is false everytime if you want to emit new ++ insn, unless you want to crash into ICE directly. */ ++ if (loongarch_is_quad_duplicate (d)) ++ { ++ /* Selector example: E_V8SImode, { 0, 0, 0, 0, 4, 4, 4, 4 } ++ copy first elem from original selector to all elem in new selector. */ ++ idx = d->perm0; ++ for (i = 0; i < d->nelt; i += 1) ++ { ++ remappedi = idx; ++ } ++ /* Selector after: { 0, 0, 0, 0, 0, 0, 0, 0 }. */ ++ } ++ else if (loongarch_is_double_duplicate (d)) ++ { ++ /* Selector example: E_V8SImode, { 1, 1, 3, 3, 5, 5, 7, 7 } ++ one_vector_p == true. */ ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ idx = d->permi; ++ remappedi = idx; ++ remappedi + d->nelt / 2 = idx; ++ } ++ /* Selector after: { 1, 1, 3, 3, 1, 1, 3, 3 }. */ ++ } ++ else if (loongarch_is_odd_extraction (d) ++ || loongarch_is_even_extraction (d)) ++ { ++ /* Odd extraction selector sample: E_V4DImode, { 1, 3, 5, 7 } ++ Selector after: { 1, 3, 1, 3 }. ++ Even extraction selector sample: E_V4DImode, { 0, 2, 4, 6 } ++ Selector after: { 0, 2, 0, 2 }. */ ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ idx = d->permi; ++ remappedi = idx; ++ remappedi + d->nelt / 2 = idx; ++ } ++ /* Additional insn is required for correct result. See codes below. */ ++ extract_ev_od = true; ++ } ++ else if (loongarch_is_extraction_permutation (d)) ++ { ++ /* Selector sample: E_V8SImode, { 0, 1, 2, 3, 4, 5, 6, 7 }. */ ++ if (d->perm0 == 0) ++ { ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ remappedi = i; ++ remappedi + d->nelt / 2 = i; ++ } ++ } ++ else ++ { ++ /* { 8, 9, 10, 11, 12, 13, 14, 15 }. */ ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ idx = i + d->nelt / 2; ++ remappedi = idx; ++ remappedi + d->nelt / 2 = idx; ++ } ++ } ++ /* Selector after: { 0, 1, 2, 3, 0, 1, 2, 3 } ++ { 8, 9, 10, 11, 8, 9, 10, 11 } */ ++ } ++ else if (loongarch_is_center_extraction (d)) ++ { ++ /* sample: E_V4DImode, { 2, 3, 4, 5 } ++ In this condition, we can just copy high 128bit of op0 and low 128bit ++ of op1 to the target register by using xvpermi.q insn. */ ++ if (!d->testing_p) ++ { ++ emit_move_insn (d->target, d->op1); ++ switch (d->vmode) ++ { ++ case E_V4DImode: ++ emit_insn (gen_lasx_xvpermi_q_v4di (d->target, d->target, ++ d->op0, GEN_INT (0x21))); ++ break; ++ case E_V4DFmode: ++ emit_insn (gen_lasx_xvpermi_q_v4df (d->target, d->target, ++ d->op0, GEN_INT (0x21))); ++ break; ++ case E_V8SImode: ++ emit_insn (gen_lasx_xvpermi_q_v8si (d->target, d->target, ++ d->op0, GEN_INT (0x21))); ++ break; ++ case E_V8SFmode: ++ emit_insn (gen_lasx_xvpermi_q_v8sf (d->target, d->target, ++ d->op0, GEN_INT (0x21))); ++ break; ++ case E_V16HImode: ++ emit_insn (gen_lasx_xvpermi_q_v16hi (d->target, d->target, ++ d->op0, GEN_INT (0x21))); ++ break; ++ case E_V32QImode: ++ emit_insn (gen_lasx_xvpermi_q_v32qi (d->target, d->target, ++ d->op0, GEN_INT (0x21))); ++ break; ++ default: ++ break; ++ } ++ } ++ ok = true; ++ /* Finish the funtion directly. */ ++ goto expand_perm_const_2_end; ++ } ++ else if (loongarch_is_reversing_permutation (d)) ++ { ++ /* Selector sample: E_V8SImode, { 7, 6, 5, 4, 3, 2, 1, 0 } ++ one_vector_p == true */ ++ idx = d->nelt / 2 - 1; ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ remappedi = idx; ++ remappedi + d->nelt / 2 = idx; ++ idx -= 1; ++ } ++ /* Selector after: { 3, 2, 1, 0, 3, 2, 1, 0 } ++ Additional insn will be generated to swap hi and lo 128bit of target ++ register. */ ++ reverse_hi_lo = true; ++ } ++ else if (loongarch_is_di_misalign_extract (d) ++ || loongarch_is_si_misalign_extract (d)) ++ { ++ /* Selector Sample: ++ DI misalign: E_V4DImode, { 1, 2, 3, 4 } ++ SI misalign: E_V8SImode, { 1, 2, 3, 4, 5, 6, 7, 8 } */ ++ if (!d->testing_p) ++ { ++ /* Copy original op0/op1 value to new temp register. ++ In some cases, operand register may be used in multiple place, so ++ we need new regiter instead modify original one, to avoid runtime ++ crashing or wrong value after execution. */ ++ use_alt_op = true; ++ op1_alt = gen_reg_rtx (d->vmode); ++ emit_move_insn (op1_alt, d->op1); ++ ++ /* Adjust op1 for selecting correct value in high 128bit of target ++ register. ++ op1: E_V4DImode, { 4, 5, 6, 7 } -> { 2, 3, 4, 5 }. */ ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, op1_alt, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, d->op0, 0); ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op1, conv_op1, ++ conv_op0, GEN_INT (0x21))); ++ ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ remappedi = d->permi; ++ remappedi + d->nelt / 2 = d->permi; ++ } ++ /* Selector after: ++ DI misalign: { 1, 2, 1, 2 } ++ SI misalign: { 1, 2, 3, 4, 1, 2, 3, 4 } */ ++ } ++ } ++ else if (loongarch_is_lasx_lowpart_interleave (d)) ++ { ++ /* Elements from op0's low 18bit and op1's 128bit are inserted into ++ target register alternately. ++ sample: E_V4DImode, { 0, 4, 1, 5 } */ ++ if (!d->testing_p) ++ { ++ /* Prepare temp register instead of modify original op. */ ++ use_alt_op = true; ++ op1_alt = gen_reg_rtx (d->vmode); ++ op0_alt = gen_reg_rtx (d->vmode); ++ emit_move_insn (op1_alt, d->op1); ++ emit_move_insn (op0_alt, d->op0); ++ ++ /* Generate subreg for fitting into insn gen function. */ ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, op1_alt, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, op0_alt, 0); ++ ++ /* Adjust op value in temp register. ++ op0 = {0,1,2,3}, op1 = {4,5,0,1} */ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op1, conv_op1, ++ conv_op0, GEN_INT (0x02))); ++ /* op0 = {0,1,4,5}, op1 = {4,5,0,1} */ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op0, conv_op0, ++ conv_op1, GEN_INT (0x01))); ++ ++ /* Remap indices in selector based on the location of index inside ++ selector, and vector element numbers in current vector mode. */ ++ ++ /* Filling low 128bit of new selector. */ ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ /* value in odd-indexed slot of low 128bit part of selector ++ vector. */ ++ remappedi = i % 2 != 0 ? d->permi - d->nelt / 2 : d->permi; ++ } ++ /* Then filling the high 128bit. */ ++ for (i = d->nelt / 2; i < d->nelt; i += 1) ++ { ++ /* value in even-indexed slot of high 128bit part of ++ selector vector. */ ++ remappedi = i % 2 == 0 ++ ? d->permi + (d->nelt / 2) * 3 : d->permi; ++ } ++ } ++ } ++ else if (loongarch_is_lasx_lowpart_interleave_2 (d)) ++ { ++ /* Special lowpart interleave case in V32QI vector mode. It does the same ++ thing as we can see in if branch that above this line. ++ Selector sample: E_V32QImode, ++ {0, 1, 2, 3, 4, 5, 6, 7, 32, 33, 34, 35, 36, 37, 38, 39, 8, ++ 9, 10, 11, 12, 13, 14, 15, 40, 41, 42, 43, 44, 45, 46, 47} */ ++ if (!d->testing_p) ++ { ++ /* Solution for this case in very simple - covert op into V4DI mode, ++ and do same thing as previous if branch. */ ++ op1_alt = gen_reg_rtx (d->vmode); ++ op0_alt = gen_reg_rtx (d->vmode); ++ emit_move_insn (op1_alt, d->op1); ++ emit_move_insn (op0_alt, d->op0); ++ ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, op1_alt, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, op0_alt, 0); ++ rtx conv_target = gen_rtx_SUBREG (E_V4DImode, d->target, 0); ++ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op1, conv_op1, ++ conv_op0, GEN_INT (0x02))); ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op0, conv_op0, ++ conv_op1, GEN_INT (0x01))); ++ remapped0 = 0; ++ remapped1 = 4; ++ remapped2 = 1; ++ remapped3 = 5; ++ ++ for (i = 0; i < d->nelt; i += 1) ++ { ++ rpermi = GEN_INT (remappedi); ++ } ++ ++ sel = gen_rtx_CONST_VECTOR (E_V4DImode, gen_rtvec_v (4, rperm)); ++ sel = force_reg (E_V4DImode, sel); ++ emit_insn (gen_lasx_xvshuf_d (conv_target, sel, ++ conv_op1, conv_op0)); ++ } ++ ++ ok = true; ++ goto expand_perm_const_2_end; ++ } ++ else if (loongarch_is_lasx_lowpart_extract (d)) ++ { ++ /* Copy op0's low 128bit to target's low 128bit, and copy op1's low ++ 128bit to target's high 128bit. ++ Selector sample: E_V4DImode, { 0, 1, 4 ,5 } */ ++ if (!d->testing_p) ++ { ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, d->op1, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, d->op0, 0); ++ rtx conv_target = gen_rtx_SUBREG (E_V4DImode, d->target, 0); ++ ++ /* We can achieve the expectation by using sinple xvpermi.q insn. */ ++ emit_move_insn (conv_target, conv_op1); ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_target, conv_target, ++ conv_op0, GEN_INT (0x20))); ++ } ++ ++ ok = true; ++ goto expand_perm_const_2_end; ++ } ++ else if (loongarch_is_lasx_highpart_interleave (d)) ++ { ++ /* Similar to lowpart interleave, elements from op0's high 128bit and ++ op1's high 128bit are inserted into target regiter alternately. ++ Selector sample: E_V8SImode, { 4, 12, 5, 13, 6, 14, 7, 15 } */ ++ if (!d->testing_p) ++ { ++ /* Prepare temp op register. */ ++ use_alt_op = true; ++ op1_alt = gen_reg_rtx (d->vmode); ++ op0_alt = gen_reg_rtx (d->vmode); ++ emit_move_insn (op1_alt, d->op1); ++ emit_move_insn (op0_alt, d->op0); ++ ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, op1_alt, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, op0_alt, 0); ++ /* Adjust op value in temp regiter. ++ op0 = { 0, 1, 2, 3 }, op1 = { 6, 7, 2, 3 } */ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op1, conv_op1, ++ conv_op0, GEN_INT (0x13))); ++ /* op0 = { 2, 3, 6, 7 }, op1 = { 6, 7, 2, 3 } */ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op0, conv_op0, ++ conv_op1, GEN_INT (0x01))); ++ /* Remap indices in selector based on the location of index inside ++ selector, and vector element numbers in current vector mode. */ ++ ++ /* Filling low 128bit of new selector. */ ++ for (i = 0; i < d->nelt / 2; i += 1) ++ { ++ /* value in even-indexed slot of low 128bit part of selector ++ vector. */ ++ remappedi = i % 2 == 0 ? d->permi - d->nelt / 2 : d->permi; ++ } ++ /* Then filling the high 128bit. */ ++ for (i = d->nelt / 2; i < d->nelt; i += 1) ++ { ++ /* value in odd-indexed slot of high 128bit part of selector ++ vector. */ ++ remappedi = i % 2 != 0 ++ ? d->permi - (d->nelt / 2) * 3 : d->permi; ++ } ++ } ++ } ++ else if (loongarch_is_lasx_highpart_interleave_2 (d)) ++ { ++ /* Special highpart interleave case in V32QI vector mode. It does the ++ same thing as the normal version above. ++ Selector sample: E_V32QImode, ++ {16, 17, 18, 19, 20, 21, 22, 23, 48, 49, 50, 51, 52, 53, 54, 55, ++ 24, 25, 26, 27, 28, 29, 30, 31, 56, 57, 58, 59, 60, 61, 62, 63} ++ */ ++ if (!d->testing_p) ++ { ++ /* Convert op into V4DImode and do the things. */ ++ op1_alt = gen_reg_rtx (d->vmode); ++ op0_alt = gen_reg_rtx (d->vmode); ++ emit_move_insn (op1_alt, d->op1); ++ emit_move_insn (op0_alt, d->op0); ++ ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, op1_alt, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, op0_alt, 0); ++ rtx conv_target = gen_rtx_SUBREG (E_V4DImode, d->target, 0); ++ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op1, conv_op1, ++ conv_op0, GEN_INT (0x13))); ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op0, conv_op0, ++ conv_op1, GEN_INT (0x01))); ++ remapped0 = 2; ++ remapped1 = 6; ++ remapped2 = 3; ++ remapped3 = 7; ++ ++ for (i = 0; i < d->nelt; i += 1) ++ { ++ rpermi = GEN_INT (remappedi); ++ } ++ ++ sel = gen_rtx_CONST_VECTOR (E_V4DImode, gen_rtvec_v (4, rperm)); ++ sel = force_reg (E_V4DImode, sel); ++ emit_insn (gen_lasx_xvshuf_d (conv_target, sel, ++ conv_op1, conv_op0)); ++ } ++ ++ ok = true; ++ goto expand_perm_const_2_end; ++ } ++ else if (loongarch_is_elem_duplicate (d)) ++ { ++ /* Brocast single element (from op0 or op1) to all slot of target ++ register. ++ Selector sample:E_V8SImode, { 2, 2, 2, 2, 2, 2, 2, 2 } */ ++ if (!d->testing_p) ++ { ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, d->op1, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, d->op0, 0); ++ rtx temp_reg = gen_reg_rtx (d->vmode); ++ rtx conv_temp = gen_rtx_SUBREG (E_V4DImode, temp_reg, 0); ++ ++ emit_move_insn (temp_reg, d->op0); ++ ++ idx = d->perm0; ++ /* We will use xvrepl128vei.* insn to achieve the result, but we need ++ to make the high/low 128bit has the same contents that contain the ++ value that we need to broardcast, because xvrepl128vei does the ++ broardcast job from every 128bit of source register to ++ corresponded part of target register! (A deep sigh.) */ ++ if (/*idx >= 0 &&*/ idx < d->nelt / 2) ++ { ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_temp, conv_temp, ++ conv_op0, GEN_INT (0x0))); ++ } ++ else if (idx >= d->nelt / 2 && idx < d->nelt) ++ { ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_temp, conv_temp, ++ conv_op0, GEN_INT (0x11))); ++ idx -= d->nelt / 2; ++ } ++ else if (idx >= d->nelt && idx < (d->nelt + d->nelt / 2)) ++ { ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_temp, conv_temp, ++ conv_op1, GEN_INT (0x0))); ++ } ++ else if (idx >= (d->nelt + d->nelt / 2) && idx < d->nelt * 2) ++ { ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_temp, conv_temp, ++ conv_op1, GEN_INT (0x11))); ++ idx -= d->nelt / 2; ++ } ++ ++ /* Then we can finally generate this insn. */ ++ switch (d->vmode) ++ { ++ case E_V4DImode: ++ emit_insn (gen_lasx_xvrepl128vei_d (d->target, temp_reg, ++ GEN_INT (idx))); ++ break; ++ case E_V4DFmode: ++ emit_insn (gen_lasx_xvrepl128vei_d_f (d->target, temp_reg, ++ GEN_INT (idx))); ++ break; ++ case E_V8SImode: ++ emit_insn (gen_lasx_xvrepl128vei_w (d->target, temp_reg, ++ GEN_INT (idx))); ++ break; ++ case E_V8SFmode: ++ emit_insn (gen_lasx_xvrepl128vei_w_f (d->target, temp_reg, ++ GEN_INT (idx))); ++ break; ++ case E_V16HImode: ++ emit_insn (gen_lasx_xvrepl128vei_h (d->target, temp_reg, ++ GEN_INT (idx))); ++ break; ++ case E_V32QImode: ++ emit_insn (gen_lasx_xvrepl128vei_b (d->target, temp_reg, ++ GEN_INT (idx))); ++ break; ++ default: ++ gcc_unreachable (); ++ break; ++ } ++ ++ /* finish func directly. */ ++ ok = true; ++ goto expand_perm_const_2_end; ++ } ++ } ++ else if (loongarch_is_op_reverse_perm (d)) ++ { ++ /* reverse high 128bit and low 128bit in op0. ++ Selector sample: E_V4DFmode, { 2, 3, 0, 1 } ++ Use xvpermi.q for doing this job. */ ++ if (!d->testing_p) ++ { ++ if (d->vmode == E_V4DImode) ++ { ++ emit_insn (gen_lasx_xvpermi_q_v4di (d->target, d->target, d->op0, ++ GEN_INT (0x01))); ++ } ++ else if (d->vmode == E_V4DFmode) ++ { ++ emit_insn (gen_lasx_xvpermi_q_v4df (d->target, d->target, d->op0, ++ GEN_INT (0x01))); ++ } ++ else ++ { ++ gcc_unreachable (); ++ } ++ } ++ ++ ok = true; ++ goto expand_perm_const_2_end; ++ } ++ else if (loongarch_is_single_op_perm (d)) ++ { ++ /* Permutation that only select elements from op0. */ ++ if (!d->testing_p) ++ { ++ /* Prepare temp register instead of modify original op. */ ++ use_alt_op = true; ++ op0_alt = gen_reg_rtx (d->vmode); ++ op1_alt = gen_reg_rtx (d->vmode); ++ ++ emit_move_insn (op0_alt, d->op0); ++ emit_move_insn (op1_alt, d->op1); ++ ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, d->op0, 0); ++ rtx conv_op0a = gen_rtx_SUBREG (E_V4DImode, op0_alt, 0); ++ rtx conv_op1a = gen_rtx_SUBREG (E_V4DImode, op1_alt, 0); ++ ++ /* Duplicate op0's low 128bit in op0, then duplicate high 128bit ++ in op1. After this, xvshuf.* insn's selector argument can ++ access all elements we need for correct permutation result. */ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op0a, conv_op0a, conv_op0, ++ GEN_INT (0x00))); ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op1a, conv_op1a, conv_op0, ++ GEN_INT (0x11))); ++ ++ /* In this case, there's no need to remap selector's indices. */ ++ for (i = 0; i < d->nelt; i += 1) ++ { ++ remappedi = d->permi; ++ } ++ } ++ } ++ else if (loongarch_is_divisible_perm (d)) ++ { ++ /* Divisible perm: ++ Low 128bit of selector only selects elements of op0, ++ and high 128bit of selector only selects elements of op1. */ ++ ++ if (!d->testing_p) ++ { ++ /* Prepare temp register instead of modify original op. */ ++ use_alt_op = true; ++ op0_alt = gen_reg_rtx (d->vmode); ++ op1_alt = gen_reg_rtx (d->vmode); ++ ++ emit_move_insn (op0_alt, d->op0); ++ emit_move_insn (op1_alt, d->op1); ++ ++ rtx conv_op0a = gen_rtx_SUBREG (E_V4DImode, op0_alt, 0); ++ rtx conv_op1a = gen_rtx_SUBREG (E_V4DImode, op1_alt, 0); ++ rtx conv_op0 = gen_rtx_SUBREG (E_V4DImode, d->op0, 0); ++ rtx conv_op1 = gen_rtx_SUBREG (E_V4DImode, d->op1, 0); ++ ++ /* Reorganize op0's hi/lo 128bit and op1's hi/lo 128bit, to make sure ++ that selector's low 128bit can access all op0's elements, and ++ selector's high 128bit can access all op1's elements. */ ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op0a, conv_op0a, conv_op1, ++ GEN_INT (0x02))); ++ emit_insn (gen_lasx_xvpermi_q_v4di (conv_op1a, conv_op1a, conv_op0, ++ GEN_INT (0x31))); ++ ++ /* No need to modify indices. */ ++ for (i = 0; i < d->nelt;i += 1) ++ { ++ remappedi = d->permi; ++ } ++ } ++ } ++ else if (loongarch_is_triple_stride_extract (d)) ++ { ++ /* Selector sample: E_V4DFmode, { 1, 4, 7, 0 }. */ ++ if (!d->testing_p) ++ { ++ /* Resolve it with brute force modification. */ ++ remapped0 = 1; ++ remapped1 = 2; ++ remapped2 = 3; ++ remapped3 = 0; ++ } ++ } ++ else ++ { ++ /* When all of the detections above are failed, we will try last ++ strategy. ++ The for loop tries to detect following rules based on indices' value, ++ its position inside of selector vector ,and strange behavior of ++ xvshuf.* insn; Then we take corresponding action. (Replace with new ++ value, or give up whole permutation expansion.) */ ++ for (i = 0; i < d->nelt; i += 1) ++ { ++ /* % (2 * d->nelt) */ ++ idx = d->permi; ++ ++ /* if index is located in low 128bit of selector vector. */ ++ if (i < d->nelt / 2) ++ { ++ /* Fail case 1: index tries to reach element that located in op0's ++ high 128bit. */ ++ if (idx >= d->nelt / 2 && idx < d->nelt) ++ { ++ goto expand_perm_const_2_end; ++ } ++ /* Fail case 2: index tries to reach element that located in ++ op1's high 128bit. */ ++ if (idx >= (d->nelt + d->nelt / 2)) ++ { ++ goto expand_perm_const_2_end; ++ } ++ ++ /* Success case: index tries to reach elements that located in ++ op1's low 128bit. Apply - (nelt / 2) offset to original ++ value. */ ++ if (idx >= d->nelt && idx < (d->nelt + d->nelt / 2)) ++ { ++ idx -= d->nelt / 2; ++ } ++ } ++ /* if index is located in high 128bit of selector vector. */ ++ else ++ { ++ /* Fail case 1: index tries to reach element that located in ++ op1's low 128bit. */ ++ if (idx >= d->nelt && idx < (d->nelt + d->nelt / 2)) ++ { ++ goto expand_perm_const_2_end; ++ } ++ /* Fail case 2: index tries to reach element that located in ++ op0's low 128bit. */ ++ if (idx < (d->nelt / 2)) ++ { ++ goto expand_perm_const_2_end; ++ } ++ /* Success case: index tries to reach element that located in ++ op0's high 128bit. */ ++ if (idx >= d->nelt / 2 && idx < d->nelt) ++ { ++ idx -= d->nelt / 2; ++ } ++ } ++ /* No need to process other case that we did not mentioned. */ ++ ++ /* Assign with original or processed value. */ ++ remappedi = idx; ++ } ++ } ++ ++ ok = true; ++ /* If testing_p is true, compiler is trying to figure out that backend can ++ handle this permutation, but doesn't want to generate actual insn. So ++ if true, exit directly. */ ++ if (d->testing_p) ++ { ++ goto expand_perm_const_2_end; ++ } ++ ++ /* Convert remapped selector array to RTL array. */ ++ for (i = 0; i < d->nelt; i += 1) ++ { ++ rpermi = GEN_INT (remappedi); ++ } ++ ++ /* Copy selector vector from memory to vector regiter for later insn gen ++ function. ++ If vector's element in floating point value, we cannot fit selector ++ argument into insn gen function directly, because of the insn template ++ definition. As a solution, generate a integral mode subreg of target, ++ then copy selector vector (that is in integral mode) to this subreg. */ ++ switch (d->vmode) ++ { ++ case E_V4DFmode: ++ sel = gen_rtx_CONST_VECTOR (E_V4DImode, gen_rtvec_v (d->nelt, rperm)); ++ tmp = gen_rtx_SUBREG (E_V4DImode, d->target, 0); ++ emit_move_insn (tmp, sel); ++ break; ++ case E_V8SFmode: ++ sel = gen_rtx_CONST_VECTOR (E_V8SImode, gen_rtvec_v (d->nelt, rperm)); ++ tmp = gen_rtx_SUBREG (E_V8SImode, d->target, 0); ++ emit_move_insn (tmp, sel); ++ break; ++ default: ++ sel = gen_rtx_CONST_VECTOR (d->vmode, gen_rtvec_v (d->nelt, rperm)); ++ emit_move_insn (d->target, sel); ++ break; ++ } ++ ++ target = d->target; ++ /* If temp op registers are requested in previous if branch, then use temp ++ register intead of original one. */ ++ if (use_alt_op) ++ { ++ op0 = op0_alt != NULL_RTX ? op0_alt : d->op0; ++ op1 = op1_alt != NULL_RTX ? op1_alt : d->op1; ++ } ++ else ++ { ++ op0 = d->op0; ++ op1 = d->one_vector_p ? d->op0 : d->op1; ++ } ++ ++ /* We FINALLY can generate xvshuf.* insn. */ ++ switch (d->vmode) ++ { ++ case E_V4DFmode: ++ emit_insn (gen_lasx_xvshuf_d_f (target, target, op1, op0)); ++ break; ++ case E_V4DImode: ++ emit_insn (gen_lasx_xvshuf_d (target, target, op1, op0)); ++ break; ++ case E_V8SFmode: ++ emit_insn (gen_lasx_xvshuf_w_f (target, target, op1, op0)); ++ break; ++ case E_V8SImode: ++ emit_insn (gen_lasx_xvshuf_w (target, target, op1, op0)); ++ break; ++ case E_V16HImode: ++ emit_insn (gen_lasx_xvshuf_h (target, target, op1, op0)); ++ break; ++ case E_V32QImode: ++ emit_insn (gen_lasx_xvshuf_b (target, op1, op0, target)); ++ break; ++ default: ++ gcc_unreachable (); ++ break; ++ } ++ ++ /* Extra insn for swapping the hi/lo 128bit of target vector register. */ ++ if (reverse_hi_lo) ++ { ++ switch (d->vmode) ++ { ++ case E_V4DFmode: ++ emit_insn (gen_lasx_xvpermi_q_v4df (d->target, d->target, ++ d->target, GEN_INT (0x1))); ++ break; ++ case E_V4DImode: ++ emit_insn (gen_lasx_xvpermi_q_v4di (d->target, d->target, ++ d->target, GEN_INT (0x1))); ++ break; ++ case E_V8SFmode: ++ emit_insn (gen_lasx_xvpermi_q_v8sf (d->target, d->target, ++ d->target, GEN_INT (0x1))); ++ break; ++ case E_V8SImode: ++ emit_insn (gen_lasx_xvpermi_q_v8si (d->target, d->target, ++ d->target, GEN_INT (0x1))); ++ break; ++ case E_V16HImode: ++ emit_insn (gen_lasx_xvpermi_q_v16hi (d->target, d->target, ++ d->target, GEN_INT (0x1))); ++ break; ++ case E_V32QImode: ++ emit_insn (gen_lasx_xvpermi_q_v32qi (d->target, d->target, ++ d->target, GEN_INT (0x1))); ++ break; ++ default: ++ break; ++ } ++ } ++ /* Extra insn required by odd/even extraction. Swapping the second and third ++ 64bit in target vector register. */ ++ else if (extract_ev_od) ++ { ++ rtx converted = gen_rtx_SUBREG (E_V4DImode, d->target, 0); ++ emit_insn (gen_lasx_xvpermi_d_v4di (converted, converted, ++ GEN_INT (0xD8))); ++ } ++ ++expand_perm_const_2_end: ++ return ok; + } + + /* Implement TARGET_VECTORIZE_VEC_PERM_CONST. */ +@@ -7813,6 +9728,12 @@ loongarch_vectorize_vec_perm_const (machine_mode vmode, machine_mode op_mode, + break; + } + ++ // Do rounding for selector to avoid vshuf undefined behavior. ++ for (i = 0; i < d.nelt; i += 1) ++ { ++ d.permi %= (d.nelt * 2); ++ } ++ + if (d.testing_p) + { + d.target = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 1); +@@ -7865,7 +9786,7 @@ loongarch_cpu_sched_reassociation_width (struct loongarch_target *target, + case CPU_LOONGARCH64: + case CPU_LA464: + /* Vector part. */ +- if (LSX_SUPPORTED_MODE_P (mode)) ++ if (LSX_SUPPORTED_MODE_P (mode) || LASX_SUPPORTED_MODE_P (mode)) + { + /* Integer vector instructions execute in FP unit. + The width of integer/float-point vector instructions is 3. */ +@@ -7915,6 +9836,44 @@ loongarch_expand_vector_extract (rtx target, rtx vec, int elt) + case E_V16QImode: + break; + ++ case E_V32QImode: ++ if (ISA_HAS_LASX) ++ { ++ if (elt >= 16) ++ { ++ tmp = gen_reg_rtx (V32QImode); ++ emit_insn (gen_lasx_xvpermi_d_v32qi (tmp, vec, GEN_INT (0xe))); ++ loongarch_expand_vector_extract (target, ++ gen_lowpart (V16QImode, tmp), ++ elt & 15); ++ } ++ else ++ loongarch_expand_vector_extract (target, ++ gen_lowpart (V16QImode, vec), ++ elt & 15); ++ return; ++ } ++ break; ++ ++ case E_V16HImode: ++ if (ISA_HAS_LASX) ++ { ++ if (elt >= 8) ++ { ++ tmp = gen_reg_rtx (V16HImode); ++ emit_insn (gen_lasx_xvpermi_d_v16hi (tmp, vec, GEN_INT (0xe))); ++ loongarch_expand_vector_extract (target, ++ gen_lowpart (V8HImode, tmp), ++ elt & 7); ++ } ++ else ++ loongarch_expand_vector_extract (target, ++ gen_lowpart (V8HImode, vec), ++ elt & 7); ++ return; ++ } ++ break; ++ + default: + break; + } +@@ -7953,6 +9912,31 @@ emit_reduc_half (rtx dest, rtx src, int i) + case E_V2DFmode: + tem = gen_lsx_vbsrl_d_f (dest, src, GEN_INT (8)); + break; ++ case E_V8SFmode: ++ if (i == 256) ++ tem = gen_lasx_xvpermi_d_v8sf (dest, src, GEN_INT (0xe)); ++ else ++ tem = gen_lasx_xvshuf4i_w_f (dest, src, ++ GEN_INT (i == 128 ? 2 + (3 << 2) : 1)); ++ break; ++ case E_V4DFmode: ++ if (i == 256) ++ tem = gen_lasx_xvpermi_d_v4df (dest, src, GEN_INT (0xe)); ++ else ++ tem = gen_lasx_xvpermi_d_v4df (dest, src, const1_rtx); ++ break; ++ case E_V32QImode: ++ case E_V16HImode: ++ case E_V8SImode: ++ case E_V4DImode: ++ d = gen_reg_rtx (V4DImode); ++ if (i == 256) ++ tem = gen_lasx_xvpermi_d_v4di (d, gen_lowpart (V4DImode, src), ++ GEN_INT (0xe)); ++ else ++ tem = gen_lasx_xvbsrl_d (d, gen_lowpart (V4DImode, src), ++ GEN_INT (i/16)); ++ break; + case E_V16QImode: + case E_V8HImode: + case E_V4SImode: +@@ -8000,10 +9984,57 @@ loongarch_expand_vec_unpack (rtx operands2, bool unsigned_p, bool high_p) + { + machine_mode imode = GET_MODE (operands1); + rtx (*unpack) (rtx, rtx, rtx); ++ rtx (*extend) (rtx, rtx); + rtx (*cmpFunc) (rtx, rtx, rtx); ++ rtx (*swap_hi_lo) (rtx, rtx, rtx, rtx); + rtx tmp, dest; + +- if (ISA_HAS_LSX) ++ if (ISA_HAS_LASX && GET_MODE_SIZE (imode) == 32) ++ { ++ switch (imode) ++ { ++ case E_V8SImode: ++ if (unsigned_p) ++ extend = gen_lasx_vext2xv_du_wu; ++ else ++ extend = gen_lasx_vext2xv_d_w; ++ swap_hi_lo = gen_lasx_xvpermi_q_v8si; ++ break; ++ ++ case E_V16HImode: ++ if (unsigned_p) ++ extend = gen_lasx_vext2xv_wu_hu; ++ else ++ extend = gen_lasx_vext2xv_w_h; ++ swap_hi_lo = gen_lasx_xvpermi_q_v16hi; ++ break; ++ ++ case E_V32QImode: ++ if (unsigned_p) ++ extend = gen_lasx_vext2xv_hu_bu; ++ else ++ extend = gen_lasx_vext2xv_h_b; ++ swap_hi_lo = gen_lasx_xvpermi_q_v32qi; ++ break; ++ ++ default: ++ gcc_unreachable (); ++ break; ++ } ++ ++ if (high_p) ++ { ++ tmp = gen_reg_rtx (imode); ++ emit_insn (swap_hi_lo (tmp, tmp, operands1, const1_rtx)); ++ emit_insn (extend (operands0, tmp)); ++ return; ++ } ++ ++ emit_insn (extend (operands0, operands1)); ++ return; ++ ++ } ++ else if (ISA_HAS_LSX) + { + switch (imode) + { +@@ -8104,8 +10135,17 @@ loongarch_gen_const_int_vector_shuffle (machine_mode mode, int val) + return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nunits, elts)); + } + ++ + /* Expand a vector initialization. */ + ++void ++loongarch_expand_vector_group_init (rtx target, rtx vals) ++{ ++ rtx ops2 = { XVECEXP (vals, 0, 0), XVECEXP (vals, 0, 1) }; ++ emit_insn (gen_rtx_SET (target, gen_rtx_VEC_CONCAT (E_V32QImode, ops0, ++ ops1))); ++} ++ + void + loongarch_expand_vector_init (rtx target, rtx vals) + { +@@ -8125,6 +10165,285 @@ loongarch_expand_vector_init (rtx target, rtx vals) + all_same = false; + } + ++ if (ISA_HAS_LASX && GET_MODE_SIZE (vmode) == 32) ++ { ++ if (all_same) ++ { ++ rtx same = XVECEXP (vals, 0, 0); ++ rtx temp, temp2; ++ ++ if (CONST_INT_P (same) && nvar == 0 ++ && loongarch_signed_immediate_p (INTVAL (same), 10, 0)) ++ { ++ switch (vmode) ++ { ++ case E_V32QImode: ++ case E_V16HImode: ++ case E_V8SImode: ++ case E_V4DImode: ++ temp = gen_rtx_CONST_VECTOR (vmode, XVEC (vals, 0)); ++ emit_move_insn (target, temp); ++ return; ++ ++ default: ++ gcc_unreachable (); ++ } ++ } ++ ++ temp = gen_reg_rtx (imode); ++ if (imode == GET_MODE (same)) ++ temp2 = same; ++ else if (GET_MODE_SIZE (imode) >= UNITS_PER_WORD) ++ { ++ if (GET_CODE (same) == MEM) ++ { ++ rtx reg_tmp = gen_reg_rtx (GET_MODE (same)); ++ loongarch_emit_move (reg_tmp, same); ++ temp2 = simplify_gen_subreg (imode, reg_tmp, ++ GET_MODE (reg_tmp), 0); ++ } ++ else ++ temp2 = simplify_gen_subreg (imode, same, ++ GET_MODE (same), 0); ++ } ++ else ++ { ++ if (GET_CODE (same) == MEM) ++ { ++ rtx reg_tmp = gen_reg_rtx (GET_MODE (same)); ++ loongarch_emit_move (reg_tmp, same); ++ temp2 = lowpart_subreg (imode, reg_tmp, ++ GET_MODE (reg_tmp)); ++ } ++ else ++ temp2 = lowpart_subreg (imode, same, GET_MODE (same)); ++ } ++ emit_move_insn (temp, temp2); ++ ++ switch (vmode) ++ { ++ case E_V32QImode: ++ case E_V16HImode: ++ case E_V8SImode: ++ case E_V4DImode: ++ loongarch_emit_move (target, ++ gen_rtx_VEC_DUPLICATE (vmode, temp)); ++ break; ++ ++ case E_V8SFmode: ++ emit_insn (gen_lasx_xvreplve0_w_f_scalar (target, temp)); ++ break; ++ ++ case E_V4DFmode: ++ emit_insn (gen_lasx_xvreplve0_d_f_scalar (target, temp)); ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ } ++ else ++ { ++ rtvec vec = shallow_copy_rtvec (XVEC (vals, 0)); ++ ++ for (i = 0; i < nelt; ++i) ++ RTVEC_ELT (vec, i) = CONST0_RTX (imode); ++ ++ emit_move_insn (target, gen_rtx_CONST_VECTOR (vmode, vec)); ++ ++ machine_mode half_mode = VOIDmode; ++ rtx target_hi, target_lo; ++ ++ switch (vmode) ++ { ++ case E_V32QImode: ++ half_mode=E_V16QImode; ++ target_hi = gen_reg_rtx (half_mode); ++ target_lo = gen_reg_rtx (half_mode); ++ for (i = 0; i < nelt/2; ++i) ++ { ++ rtx temp_hi = gen_reg_rtx (imode); ++ rtx temp_lo = gen_reg_rtx (imode); ++ emit_move_insn (temp_hi, XVECEXP (vals, 0, i+nelt/2)); ++ emit_move_insn (temp_lo, XVECEXP (vals, 0, i)); ++ if (i == 0) ++ { ++ emit_insn (gen_lsx_vreplvei_b_scalar (target_hi, ++ temp_hi)); ++ emit_insn (gen_lsx_vreplvei_b_scalar (target_lo, ++ temp_lo)); ++ } ++ else ++ { ++ emit_insn (gen_vec_setv16qi (target_hi, temp_hi, ++ GEN_INT (i))); ++ emit_insn (gen_vec_setv16qi (target_lo, temp_lo, ++ GEN_INT (i))); ++ } ++ } ++ emit_insn (gen_rtx_SET (target, ++ gen_rtx_VEC_CONCAT (vmode, target_hi, ++ target_lo))); ++ break; ++ ++ case E_V16HImode: ++ half_mode=E_V8HImode; ++ target_hi = gen_reg_rtx (half_mode); ++ target_lo = gen_reg_rtx (half_mode); ++ for (i = 0; i < nelt/2; ++i) ++ { ++ rtx temp_hi = gen_reg_rtx (imode); ++ rtx temp_lo = gen_reg_rtx (imode); ++ emit_move_insn (temp_hi, XVECEXP (vals, 0, i+nelt/2)); ++ emit_move_insn (temp_lo, XVECEXP (vals, 0, i)); ++ if (i == 0) ++ { ++ emit_insn (gen_lsx_vreplvei_h_scalar (target_hi, ++ temp_hi)); ++ emit_insn (gen_lsx_vreplvei_h_scalar (target_lo, ++ temp_lo)); ++ } ++ else ++ { ++ emit_insn (gen_vec_setv8hi (target_hi, temp_hi, ++ GEN_INT (i))); ++ emit_insn (gen_vec_setv8hi (target_lo, temp_lo, ++ GEN_INT (i))); ++ } ++ } ++ emit_insn (gen_rtx_SET (target, ++ gen_rtx_VEC_CONCAT (vmode, target_hi, ++ target_lo))); ++ break; ++ ++ case E_V8SImode: ++ half_mode=V4SImode; ++ target_hi = gen_reg_rtx (half_mode); ++ target_lo = gen_reg_rtx (half_mode); ++ for (i = 0; i < nelt/2; ++i) ++ { ++ rtx temp_hi = gen_reg_rtx (imode); ++ rtx temp_lo = gen_reg_rtx (imode); ++ emit_move_insn (temp_hi, XVECEXP (vals, 0, i+nelt/2)); ++ emit_move_insn (temp_lo, XVECEXP (vals, 0, i)); ++ if (i == 0) ++ { ++ emit_insn (gen_lsx_vreplvei_w_scalar (target_hi, ++ temp_hi)); ++ emit_insn (gen_lsx_vreplvei_w_scalar (target_lo, ++ temp_lo)); ++ } ++ else ++ { ++ emit_insn (gen_vec_setv4si (target_hi, temp_hi, ++ GEN_INT (i))); ++ emit_insn (gen_vec_setv4si (target_lo, temp_lo, ++ GEN_INT (i))); ++ } ++ } ++ emit_insn (gen_rtx_SET (target, ++ gen_rtx_VEC_CONCAT (vmode, target_hi, ++ target_lo))); ++ break; ++ ++ case E_V4DImode: ++ half_mode=E_V2DImode; ++ target_hi = gen_reg_rtx (half_mode); ++ target_lo = gen_reg_rtx (half_mode); ++ for (i = 0; i < nelt/2; ++i) ++ { ++ rtx temp_hi = gen_reg_rtx (imode); ++ rtx temp_lo = gen_reg_rtx (imode); ++ emit_move_insn (temp_hi, XVECEXP (vals, 0, i+nelt/2)); ++ emit_move_insn (temp_lo, XVECEXP (vals, 0, i)); ++ if (i == 0) ++ { ++ emit_insn (gen_lsx_vreplvei_d_scalar (target_hi, ++ temp_hi)); ++ emit_insn (gen_lsx_vreplvei_d_scalar (target_lo, ++ temp_lo)); ++ } ++ else ++ { ++ emit_insn (gen_vec_setv2di (target_hi, temp_hi, ++ GEN_INT (i))); ++ emit_insn (gen_vec_setv2di (target_lo, temp_lo, ++ GEN_INT (i))); ++ } ++ } ++ emit_insn (gen_rtx_SET (target, ++ gen_rtx_VEC_CONCAT (vmode, target_hi, ++ target_lo))); ++ break; ++ ++ case E_V8SFmode: ++ half_mode=E_V4SFmode; ++ target_hi = gen_reg_rtx (half_mode); ++ target_lo = gen_reg_rtx (half_mode); ++ for (i = 0; i < nelt/2; ++i) ++ { ++ rtx temp_hi = gen_reg_rtx (imode); ++ rtx temp_lo = gen_reg_rtx (imode); ++ emit_move_insn (temp_hi, XVECEXP (vals, 0, i+nelt/2)); ++ emit_move_insn (temp_lo, XVECEXP (vals, 0, i)); ++ if (i == 0) ++ { ++ emit_insn (gen_lsx_vreplvei_w_f_scalar (target_hi, ++ temp_hi)); ++ emit_insn (gen_lsx_vreplvei_w_f_scalar (target_lo, ++ temp_lo)); ++ } ++ else ++ { ++ emit_insn (gen_vec_setv4sf (target_hi, temp_hi, ++ GEN_INT (i))); ++ emit_insn (gen_vec_setv4sf (target_lo, temp_lo, ++ GEN_INT (i))); ++ } ++ } ++ emit_insn (gen_rtx_SET (target, ++ gen_rtx_VEC_CONCAT (vmode, target_hi, ++ target_lo))); ++ break; ++ ++ case E_V4DFmode: ++ half_mode=E_V2DFmode; ++ target_hi = gen_reg_rtx (half_mode); ++ target_lo = gen_reg_rtx (half_mode); ++ for (i = 0; i < nelt/2; ++i) ++ { ++ rtx temp_hi = gen_reg_rtx (imode); ++ rtx temp_lo = gen_reg_rtx (imode); ++ emit_move_insn (temp_hi, XVECEXP (vals, 0, i+nelt/2)); ++ emit_move_insn (temp_lo, XVECEXP (vals, 0, i)); ++ if (i == 0) ++ { ++ emit_insn (gen_lsx_vreplvei_d_f_scalar (target_hi, ++ temp_hi)); ++ emit_insn (gen_lsx_vreplvei_d_f_scalar (target_lo, ++ temp_lo)); ++ } ++ else ++ { ++ emit_insn (gen_vec_setv2df (target_hi, temp_hi, ++ GEN_INT (i))); ++ emit_insn (gen_vec_setv2df (target_lo, temp_lo, ++ GEN_INT (i))); ++ } ++ } ++ emit_insn (gen_rtx_SET (target, ++ gen_rtx_VEC_CONCAT (vmode, target_hi, ++ target_lo))); ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ ++ } ++ return; ++ } ++ + if (ISA_HAS_LSX) + { + if (all_same) +@@ -8372,6 +10691,38 @@ loongarch_expand_lsx_cmp (rtx dest, enum rtx_code cond, rtx op0, rtx op1) + } + break; + ++ case E_V8SFmode: ++ case E_V4DFmode: ++ switch (cond) ++ { ++ case UNORDERED: ++ case ORDERED: ++ case EQ: ++ case NE: ++ case UNEQ: ++ case UNLE: ++ case UNLT: ++ break; ++ case LTGT: cond = NE; break; ++ case UNGE: cond = UNLE; std::swap (op0, op1); break; ++ case UNGT: cond = UNLT; std::swap (op0, op1); break; ++ case LE: unspec = UNSPEC_LASX_XVFCMP_SLE; break; ++ case LT: unspec = UNSPEC_LASX_XVFCMP_SLT; break; ++ case GE: unspec = UNSPEC_LASX_XVFCMP_SLE; std::swap (op0, op1); break; ++ case GT: unspec = UNSPEC_LASX_XVFCMP_SLT; std::swap (op0, op1); break; ++ default: ++ gcc_unreachable (); ++ } ++ if (unspec < 0) ++ loongarch_emit_binary (cond, dest, op0, op1); ++ else ++ { ++ rtx x = gen_rtx_UNSPEC (GET_MODE (dest), ++ gen_rtvec (2, op0, op1), unspec); ++ emit_insn (gen_rtx_SET (dest, x)); ++ } ++ break; ++ + default: + gcc_unreachable (); + break; +@@ -8709,7 +11060,7 @@ loongarch_builtin_support_vector_misalignment (machine_mode mode, + int misalignment, + bool is_packed) + { +- if (ISA_HAS_LSX && STRICT_ALIGNMENT) ++ if ((ISA_HAS_LSX || ISA_HAS_LASX) && STRICT_ALIGNMENT) + { + if (optab_handler (movmisalign_optab, mode) == CODE_FOR_nothing) + return false; +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index c3ebea2f2..b2295c589 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -186,6 +186,11 @@ along with GCC; see the file COPYING3. If not see + /* Width of a LSX vector register in bits. */ + #define BITS_PER_LSX_REG (UNITS_PER_LSX_REG * BITS_PER_UNIT) + ++/* Width of a LASX vector register in bytes. */ ++#define UNITS_PER_LASX_REG 32 ++/* Width of a LASX vector register in bits. */ ++#define BITS_PER_LASX_REG (UNITS_PER_LASX_REG * BITS_PER_UNIT) ++ + /* For LARCH, width of a floating point register. */ + #define UNITS_PER_FPREG (TARGET_DOUBLE_FLOAT ? 8 : 4) + +@@ -248,10 +253,11 @@ along with GCC; see the file COPYING3. If not see + #define STRUCTURE_SIZE_BOUNDARY 8 + + /* There is no point aligning anything to a rounder boundary than +- LONG_DOUBLE_TYPE_SIZE, unless under LSX the bigggest alignment is +- BITS_PER_LSX_REG/.. */ ++ LONG_DOUBLE_TYPE_SIZE, unless under LSX/LASX the bigggest alignment is ++ BITS_PER_LSX_REG/BITS_PER_LASX_REG/.. */ + #define BIGGEST_ALIGNMENT \ +- (ISA_HAS_LSX ? BITS_PER_LSX_REG : LONG_DOUBLE_TYPE_SIZE) ++ (ISA_HAS_LASX? BITS_PER_LASX_REG \ ++ : (ISA_HAS_LSX ? BITS_PER_LSX_REG : LONG_DOUBLE_TYPE_SIZE)) + + /* All accesses must be aligned. */ + #define STRICT_ALIGNMENT (TARGET_STRICT_ALIGN) +@@ -391,6 +397,10 @@ along with GCC; see the file COPYING3. If not see + #define LSX_REG_LAST FP_REG_LAST + #define LSX_REG_NUM FP_REG_NUM + ++#define LASX_REG_FIRST FP_REG_FIRST ++#define LASX_REG_LAST FP_REG_LAST ++#define LASX_REG_NUM FP_REG_NUM ++ + /* The DWARF 2 CFA column which tracks the return address from a + signal handler context. This means that to maintain backwards + compatibility, no hard register can be assigned this column if it +@@ -409,9 +419,12 @@ along with GCC; see the file COPYING3. If not see + ((unsigned int) ((int) (REGNO) - FCC_REG_FIRST) < FCC_REG_NUM) + #define LSX_REG_P(REGNO) \ + ((unsigned int) ((int) (REGNO) - LSX_REG_FIRST) < LSX_REG_NUM) ++#define LASX_REG_P(REGNO) \ ++ ((unsigned int) ((int) (REGNO) - LASX_REG_FIRST) < LASX_REG_NUM) + + #define FP_REG_RTX_P(X) (REG_P (X) && FP_REG_P (REGNO (X))) + #define LSX_REG_RTX_P(X) (REG_P (X) && LSX_REG_P (REGNO (X))) ++#define LASX_REG_RTX_P(X) (REG_P (X) && LASX_REG_P (REGNO (X))) + + /* Select a register mode required for caller save of hard regno REGNO. */ + #define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE) \ +@@ -733,6 +746,13 @@ enum reg_class + && (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)) + ++#define LASX_SUPPORTED_MODE_P(MODE) \ ++ (ISA_HAS_LASX \ ++ && (GET_MODE_SIZE (MODE) == UNITS_PER_LSX_REG \ ++ ||GET_MODE_SIZE (MODE) == UNITS_PER_LASX_REG) \ ++ && (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \ ++ || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)) ++ + /* 1 if N is a possible register number for function argument passing. + We have no FP argument registers when soft-float. */ + +@@ -985,7 +1005,39 @@ typedef struct { + { "vr28", 28 + FP_REG_FIRST }, \ + { "vr29", 29 + FP_REG_FIRST }, \ + { "vr30", 30 + FP_REG_FIRST }, \ +- { "vr31", 31 + FP_REG_FIRST } \ ++ { "vr31", 31 + FP_REG_FIRST }, \ ++ { "xr0", 0 + FP_REG_FIRST }, \ ++ { "xr1", 1 + FP_REG_FIRST }, \ ++ { "xr2", 2 + FP_REG_FIRST }, \ ++ { "xr3", 3 + FP_REG_FIRST }, \ ++ { "xr4", 4 + FP_REG_FIRST }, \ ++ { "xr5", 5 + FP_REG_FIRST }, \ ++ { "xr6", 6 + FP_REG_FIRST }, \ ++ { "xr7", 7 + FP_REG_FIRST }, \ ++ { "xr8", 8 + FP_REG_FIRST }, \ ++ { "xr9", 9 + FP_REG_FIRST }, \ ++ { "xr10", 10 + FP_REG_FIRST }, \ ++ { "xr11", 11 + FP_REG_FIRST }, \ ++ { "xr12", 12 + FP_REG_FIRST }, \ ++ { "xr13", 13 + FP_REG_FIRST }, \ ++ { "xr14", 14 + FP_REG_FIRST }, \ ++ { "xr15", 15 + FP_REG_FIRST }, \ ++ { "xr16", 16 + FP_REG_FIRST }, \ ++ { "xr17", 17 + FP_REG_FIRST }, \ ++ { "xr18", 18 + FP_REG_FIRST }, \ ++ { "xr19", 19 + FP_REG_FIRST }, \ ++ { "xr20", 20 + FP_REG_FIRST }, \ ++ { "xr21", 21 + FP_REG_FIRST }, \ ++ { "xr22", 22 + FP_REG_FIRST }, \ ++ { "xr23", 23 + FP_REG_FIRST }, \ ++ { "xr24", 24 + FP_REG_FIRST }, \ ++ { "xr25", 25 + FP_REG_FIRST }, \ ++ { "xr26", 26 + FP_REG_FIRST }, \ ++ { "xr27", 27 + FP_REG_FIRST }, \ ++ { "xr28", 28 + FP_REG_FIRST }, \ ++ { "xr29", 29 + FP_REG_FIRST }, \ ++ { "xr30", 30 + FP_REG_FIRST }, \ ++ { "xr31", 31 + FP_REG_FIRST } \ + } + + /* Globalizing directive for a label. */ +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index fb3828262..3dde0ceb1 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -163,7 +163,7 @@ + + ;; Main data type used by the insn + (define_attr "mode" "unknown,none,QI,HI,SI,DI,TI,SF,DF,TF,FCC, +- V2DI,V4SI,V8HI,V16QI,V2DF,V4SF" ++ V2DI,V4SI,V8HI,V16QI,V2DF,V4SF,V4DI,V8SI,V16HI,V32QI,V4DF,V8SF" + (const_string "unknown")) + + ;; True if the main data type is twice the size of a word. +@@ -422,12 +422,14 @@ + ;; floating-point mode or vector mode. + (define_mode_attr UNITMODE (SF "SF") (DF "DF") (V2SF "SF") (V4SF "SF") + (V16QI "QI") (V8HI "HI") (V4SI "SI") (V2DI "DI") +- (V2DF "DF")) ++ (V2DF "DF")(V8SF "SF")(V32QI "QI")(V16HI "HI")(V8SI "SI")(V4DI "DI")(V4DF "DF")) + + ;; As above, but in lower case. + (define_mode_attr unitmode (SF "sf") (DF "df") (V2SF "sf") (V4SF "sf") + (V16QI "qi") (V8QI "qi") (V8HI "hi") (V4HI "hi") +- (V4SI "si") (V2SI "si") (V2DI "di") (V2DF "df")) ++ (V4SI "si") (V2SI "si") (V2DI "di") (V2DF "df") ++ (V8SI "si") (V4DI "di") (V32QI "qi") (V16HI "hi") ++ (V8SF "sf") (V4DF "df")) + + ;; This attribute gives the integer mode that has half the size of + ;; the controlling mode. +@@ -711,16 +713,17 @@ + (set_attr "alu_type" "sub") + (set_attr "mode" "<MODE>")) + ++ + (define_insn "*subsi3_extended" +- (set (match_operand:DI 0 "register_operand" "= r") ++ (set (match_operand:DI 0 "register_operand" "=r") + (sign_extend:DI +- (minus:SI (match_operand:SI 1 "reg_or_0_operand" " rJ") +- (match_operand:SI 2 "register_operand" " r")))) ++ (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rJ") ++ (match_operand:SI 2 "register_operand" "r")))) + "TARGET_64BIT" + "sub.w\t%0,%z1,%2" + (set_attr "type" "arith") + (set_attr "mode" "SI")) +- ++ + ;; + ;; .................... + ;; +@@ -3638,6 +3641,9 @@ + ; The LoongArch SX Instructions. + (include "lsx.md") + ++; The LoongArch ASX Instructions. ++(include "lasx.md") ++ + (define_c_enum "unspec" + UNSPEC_ADDRESS_FIRST + ) +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-Loongson-ASX-directive-builtin-functio.patch
Added
@@ -0,0 +1,7458 @@ +From 6871a6a4ef5f10bc75a9dd76fff37302057cf528 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Fri, 25 Nov 2022 11:09:49 +0800 +Subject: PATCH 066/124 LoongArch: Add Loongson ASX directive builtin + function support. + +gcc/ChangeLog: + + * config.gcc: Export the header file lasxintrin.h. + * config/loongarch/loongarch-builtins.cc (enum loongarch_builtin_type): + Add Loongson ASX builtin functions support. + (AVAIL_ALL): Ditto. + (LASX_BUILTIN): Ditto. + (LASX_NO_TARGET_BUILTIN): Ditto. + (LASX_BUILTIN_TEST_BRANCH): Ditto. + (CODE_FOR_lasx_xvsadd_b): Ditto. + (CODE_FOR_lasx_xvsadd_h): Ditto. + (CODE_FOR_lasx_xvsadd_w): Ditto. + (CODE_FOR_lasx_xvsadd_d): Ditto. + (CODE_FOR_lasx_xvsadd_bu): Ditto. + (CODE_FOR_lasx_xvsadd_hu): Ditto. + (CODE_FOR_lasx_xvsadd_wu): Ditto. + (CODE_FOR_lasx_xvsadd_du): Ditto. + (CODE_FOR_lasx_xvadd_b): Ditto. + (CODE_FOR_lasx_xvadd_h): Ditto. + (CODE_FOR_lasx_xvadd_w): Ditto. + (CODE_FOR_lasx_xvadd_d): Ditto. + (CODE_FOR_lasx_xvaddi_bu): Ditto. + (CODE_FOR_lasx_xvaddi_hu): Ditto. + (CODE_FOR_lasx_xvaddi_wu): Ditto. + (CODE_FOR_lasx_xvaddi_du): Ditto. + (CODE_FOR_lasx_xvand_v): Ditto. + (CODE_FOR_lasx_xvandi_b): Ditto. + (CODE_FOR_lasx_xvbitsel_v): Ditto. + (CODE_FOR_lasx_xvseqi_b): Ditto. + (CODE_FOR_lasx_xvseqi_h): Ditto. + (CODE_FOR_lasx_xvseqi_w): Ditto. + (CODE_FOR_lasx_xvseqi_d): Ditto. + (CODE_FOR_lasx_xvslti_b): Ditto. + (CODE_FOR_lasx_xvslti_h): Ditto. + (CODE_FOR_lasx_xvslti_w): Ditto. + (CODE_FOR_lasx_xvslti_d): Ditto. + (CODE_FOR_lasx_xvslti_bu): Ditto. + (CODE_FOR_lasx_xvslti_hu): Ditto. + (CODE_FOR_lasx_xvslti_wu): Ditto. + (CODE_FOR_lasx_xvslti_du): Ditto. + (CODE_FOR_lasx_xvslei_b): Ditto. + (CODE_FOR_lasx_xvslei_h): Ditto. + (CODE_FOR_lasx_xvslei_w): Ditto. + (CODE_FOR_lasx_xvslei_d): Ditto. + (CODE_FOR_lasx_xvslei_bu): Ditto. + (CODE_FOR_lasx_xvslei_hu): Ditto. + (CODE_FOR_lasx_xvslei_wu): Ditto. + (CODE_FOR_lasx_xvslei_du): Ditto. + (CODE_FOR_lasx_xvdiv_b): Ditto. + (CODE_FOR_lasx_xvdiv_h): Ditto. + (CODE_FOR_lasx_xvdiv_w): Ditto. + (CODE_FOR_lasx_xvdiv_d): Ditto. + (CODE_FOR_lasx_xvdiv_bu): Ditto. + (CODE_FOR_lasx_xvdiv_hu): Ditto. + (CODE_FOR_lasx_xvdiv_wu): Ditto. + (CODE_FOR_lasx_xvdiv_du): Ditto. + (CODE_FOR_lasx_xvfadd_s): Ditto. + (CODE_FOR_lasx_xvfadd_d): Ditto. + (CODE_FOR_lasx_xvftintrz_w_s): Ditto. + (CODE_FOR_lasx_xvftintrz_l_d): Ditto. + (CODE_FOR_lasx_xvftintrz_wu_s): Ditto. + (CODE_FOR_lasx_xvftintrz_lu_d): Ditto. + (CODE_FOR_lasx_xvffint_s_w): Ditto. + (CODE_FOR_lasx_xvffint_d_l): Ditto. + (CODE_FOR_lasx_xvffint_s_wu): Ditto. + (CODE_FOR_lasx_xvffint_d_lu): Ditto. + (CODE_FOR_lasx_xvfsub_s): Ditto. + (CODE_FOR_lasx_xvfsub_d): Ditto. + (CODE_FOR_lasx_xvfmul_s): Ditto. + (CODE_FOR_lasx_xvfmul_d): Ditto. + (CODE_FOR_lasx_xvfdiv_s): Ditto. + (CODE_FOR_lasx_xvfdiv_d): Ditto. + (CODE_FOR_lasx_xvfmax_s): Ditto. + (CODE_FOR_lasx_xvfmax_d): Ditto. + (CODE_FOR_lasx_xvfmin_s): Ditto. + (CODE_FOR_lasx_xvfmin_d): Ditto. + (CODE_FOR_lasx_xvfsqrt_s): Ditto. + (CODE_FOR_lasx_xvfsqrt_d): Ditto. + (CODE_FOR_lasx_xvflogb_s): Ditto. + (CODE_FOR_lasx_xvflogb_d): Ditto. + (CODE_FOR_lasx_xvmax_b): Ditto. + (CODE_FOR_lasx_xvmax_h): Ditto. + (CODE_FOR_lasx_xvmax_w): Ditto. + (CODE_FOR_lasx_xvmax_d): Ditto. + (CODE_FOR_lasx_xvmaxi_b): Ditto. + (CODE_FOR_lasx_xvmaxi_h): Ditto. + (CODE_FOR_lasx_xvmaxi_w): Ditto. + (CODE_FOR_lasx_xvmaxi_d): Ditto. + (CODE_FOR_lasx_xvmax_bu): Ditto. + (CODE_FOR_lasx_xvmax_hu): Ditto. + (CODE_FOR_lasx_xvmax_wu): Ditto. + (CODE_FOR_lasx_xvmax_du): Ditto. + (CODE_FOR_lasx_xvmaxi_bu): Ditto. + (CODE_FOR_lasx_xvmaxi_hu): Ditto. + (CODE_FOR_lasx_xvmaxi_wu): Ditto. + (CODE_FOR_lasx_xvmaxi_du): Ditto. + (CODE_FOR_lasx_xvmin_b): Ditto. + (CODE_FOR_lasx_xvmin_h): Ditto. + (CODE_FOR_lasx_xvmin_w): Ditto. + (CODE_FOR_lasx_xvmin_d): Ditto. + (CODE_FOR_lasx_xvmini_b): Ditto. + (CODE_FOR_lasx_xvmini_h): Ditto. + (CODE_FOR_lasx_xvmini_w): Ditto. + (CODE_FOR_lasx_xvmini_d): Ditto. + (CODE_FOR_lasx_xvmin_bu): Ditto. + (CODE_FOR_lasx_xvmin_hu): Ditto. + (CODE_FOR_lasx_xvmin_wu): Ditto. + (CODE_FOR_lasx_xvmin_du): Ditto. + (CODE_FOR_lasx_xvmini_bu): Ditto. + (CODE_FOR_lasx_xvmini_hu): Ditto. + (CODE_FOR_lasx_xvmini_wu): Ditto. + (CODE_FOR_lasx_xvmini_du): Ditto. + (CODE_FOR_lasx_xvmod_b): Ditto. + (CODE_FOR_lasx_xvmod_h): Ditto. + (CODE_FOR_lasx_xvmod_w): Ditto. + (CODE_FOR_lasx_xvmod_d): Ditto. + (CODE_FOR_lasx_xvmod_bu): Ditto. + (CODE_FOR_lasx_xvmod_hu): Ditto. + (CODE_FOR_lasx_xvmod_wu): Ditto. + (CODE_FOR_lasx_xvmod_du): Ditto. + (CODE_FOR_lasx_xvmul_b): Ditto. + (CODE_FOR_lasx_xvmul_h): Ditto. + (CODE_FOR_lasx_xvmul_w): Ditto. + (CODE_FOR_lasx_xvmul_d): Ditto. + (CODE_FOR_lasx_xvclz_b): Ditto. + (CODE_FOR_lasx_xvclz_h): Ditto. + (CODE_FOR_lasx_xvclz_w): Ditto. + (CODE_FOR_lasx_xvclz_d): Ditto. + (CODE_FOR_lasx_xvnor_v): Ditto. + (CODE_FOR_lasx_xvor_v): Ditto. + (CODE_FOR_lasx_xvori_b): Ditto. + (CODE_FOR_lasx_xvnori_b): Ditto. + (CODE_FOR_lasx_xvpcnt_b): Ditto. + (CODE_FOR_lasx_xvpcnt_h): Ditto. + (CODE_FOR_lasx_xvpcnt_w): Ditto. + (CODE_FOR_lasx_xvpcnt_d): Ditto. + (CODE_FOR_lasx_xvxor_v): Ditto. + (CODE_FOR_lasx_xvxori_b): Ditto. + (CODE_FOR_lasx_xvsll_b): Ditto. + (CODE_FOR_lasx_xvsll_h): Ditto. + (CODE_FOR_lasx_xvsll_w): Ditto. + (CODE_FOR_lasx_xvsll_d): Ditto. + (CODE_FOR_lasx_xvslli_b): Ditto. + (CODE_FOR_lasx_xvslli_h): Ditto. + (CODE_FOR_lasx_xvslli_w): Ditto. + (CODE_FOR_lasx_xvslli_d): Ditto. + (CODE_FOR_lasx_xvsra_b): Ditto. + (CODE_FOR_lasx_xvsra_h): Ditto. + (CODE_FOR_lasx_xvsra_w): Ditto. + (CODE_FOR_lasx_xvsra_d): Ditto. + (CODE_FOR_lasx_xvsrai_b): Ditto. + (CODE_FOR_lasx_xvsrai_h): Ditto. + (CODE_FOR_lasx_xvsrai_w): Ditto. + (CODE_FOR_lasx_xvsrai_d): Ditto. + (CODE_FOR_lasx_xvsrl_b): Ditto. + (CODE_FOR_lasx_xvsrl_h): Ditto. + (CODE_FOR_lasx_xvsrl_w): Ditto. + (CODE_FOR_lasx_xvsrl_d): Ditto. + (CODE_FOR_lasx_xvsrli_b): Ditto. + (CODE_FOR_lasx_xvsrli_h): Ditto. + (CODE_FOR_lasx_xvsrli_w): Ditto. + (CODE_FOR_lasx_xvsrli_d): Ditto. + (CODE_FOR_lasx_xvsub_b): Ditto. + (CODE_FOR_lasx_xvsub_h): Ditto. + (CODE_FOR_lasx_xvsub_w): Ditto. + (CODE_FOR_lasx_xvsub_d): Ditto. + (CODE_FOR_lasx_xvsubi_bu): Ditto. + (CODE_FOR_lasx_xvsubi_hu): Ditto. + (CODE_FOR_lasx_xvsubi_wu): Ditto. + (CODE_FOR_lasx_xvsubi_du): Ditto. + (CODE_FOR_lasx_xvpackod_d): Ditto. + (CODE_FOR_lasx_xvpackev_d): Ditto. + (CODE_FOR_lasx_xvpickod_d): Ditto. + (CODE_FOR_lasx_xvpickev_d): Ditto. + (CODE_FOR_lasx_xvrepli_b): Ditto. + (CODE_FOR_lasx_xvrepli_h): Ditto. + (CODE_FOR_lasx_xvrepli_w): Ditto. + (CODE_FOR_lasx_xvrepli_d): Ditto. + (CODE_FOR_lasx_xvandn_v): Ditto. + (CODE_FOR_lasx_xvorn_v): Ditto. + (CODE_FOR_lasx_xvneg_b): Ditto. + (CODE_FOR_lasx_xvneg_h): Ditto. + (CODE_FOR_lasx_xvneg_w): Ditto. + (CODE_FOR_lasx_xvneg_d): Ditto. + (CODE_FOR_lasx_xvbsrl_v): Ditto. + (CODE_FOR_lasx_xvbsll_v): Ditto. + (CODE_FOR_lasx_xvfmadd_s): Ditto. + (CODE_FOR_lasx_xvfmadd_d): Ditto. + (CODE_FOR_lasx_xvfmsub_s): Ditto. + (CODE_FOR_lasx_xvfmsub_d): Ditto. + (CODE_FOR_lasx_xvfnmadd_s): Ditto. + (CODE_FOR_lasx_xvfnmadd_d): Ditto. + (CODE_FOR_lasx_xvfnmsub_s): Ditto. + (CODE_FOR_lasx_xvfnmsub_d): Ditto. + (CODE_FOR_lasx_xvpermi_q): Ditto. + (CODE_FOR_lasx_xvpermi_d): Ditto. + (CODE_FOR_lasx_xbnz_v): Ditto. + (CODE_FOR_lasx_xbz_v): Ditto. + (CODE_FOR_lasx_xvssub_b): Ditto. + (CODE_FOR_lasx_xvssub_h): Ditto. + (CODE_FOR_lasx_xvssub_w): Ditto. + (CODE_FOR_lasx_xvssub_d): Ditto. + (CODE_FOR_lasx_xvssub_bu): Ditto. + (CODE_FOR_lasx_xvssub_hu): Ditto. + (CODE_FOR_lasx_xvssub_wu): Ditto. + (CODE_FOR_lasx_xvssub_du): Ditto. + (CODE_FOR_lasx_xvabsd_b): Ditto. + (CODE_FOR_lasx_xvabsd_h): Ditto. + (CODE_FOR_lasx_xvabsd_w): Ditto. + (CODE_FOR_lasx_xvabsd_d): Ditto. + (CODE_FOR_lasx_xvabsd_bu): Ditto. + (CODE_FOR_lasx_xvabsd_hu): Ditto. + (CODE_FOR_lasx_xvabsd_wu): Ditto. + (CODE_FOR_lasx_xvabsd_du): Ditto. + (CODE_FOR_lasx_xvavg_b): Ditto. + (CODE_FOR_lasx_xvavg_h): Ditto. + (CODE_FOR_lasx_xvavg_w): Ditto. + (CODE_FOR_lasx_xvavg_d): Ditto. + (CODE_FOR_lasx_xvavg_bu): Ditto. + (CODE_FOR_lasx_xvavg_hu): Ditto. + (CODE_FOR_lasx_xvavg_wu): Ditto. + (CODE_FOR_lasx_xvavg_du): Ditto. + (CODE_FOR_lasx_xvavgr_b): Ditto. + (CODE_FOR_lasx_xvavgr_h): Ditto. + (CODE_FOR_lasx_xvavgr_w): Ditto. + (CODE_FOR_lasx_xvavgr_d): Ditto. + (CODE_FOR_lasx_xvavgr_bu): Ditto. + (CODE_FOR_lasx_xvavgr_hu): Ditto. + (CODE_FOR_lasx_xvavgr_wu): Ditto. + (CODE_FOR_lasx_xvavgr_du): Ditto. + (CODE_FOR_lasx_xvmuh_b): Ditto. + (CODE_FOR_lasx_xvmuh_h): Ditto. + (CODE_FOR_lasx_xvmuh_w): Ditto. + (CODE_FOR_lasx_xvmuh_d): Ditto. + (CODE_FOR_lasx_xvmuh_bu): Ditto. + (CODE_FOR_lasx_xvmuh_hu): Ditto. + (CODE_FOR_lasx_xvmuh_wu): Ditto. + (CODE_FOR_lasx_xvmuh_du): Ditto. + (CODE_FOR_lasx_xvssran_b_h): Ditto. + (CODE_FOR_lasx_xvssran_h_w): Ditto. + (CODE_FOR_lasx_xvssran_w_d): Ditto. + (CODE_FOR_lasx_xvssran_bu_h): Ditto. + (CODE_FOR_lasx_xvssran_hu_w): Ditto. + (CODE_FOR_lasx_xvssran_wu_d): Ditto. + (CODE_FOR_lasx_xvssrarn_b_h): Ditto. + (CODE_FOR_lasx_xvssrarn_h_w): Ditto. + (CODE_FOR_lasx_xvssrarn_w_d): Ditto. + (CODE_FOR_lasx_xvssrarn_bu_h): Ditto. + (CODE_FOR_lasx_xvssrarn_hu_w): Ditto. + (CODE_FOR_lasx_xvssrarn_wu_d): Ditto. + (CODE_FOR_lasx_xvssrln_bu_h): Ditto. + (CODE_FOR_lasx_xvssrln_hu_w): Ditto. + (CODE_FOR_lasx_xvssrln_wu_d): Ditto. + (CODE_FOR_lasx_xvssrlrn_bu_h): Ditto. + (CODE_FOR_lasx_xvssrlrn_hu_w): Ditto. + (CODE_FOR_lasx_xvssrlrn_wu_d): Ditto. + (CODE_FOR_lasx_xvftint_w_s): Ditto. + (CODE_FOR_lasx_xvftint_l_d): Ditto. + (CODE_FOR_lasx_xvftint_wu_s): Ditto. + (CODE_FOR_lasx_xvftint_lu_d): Ditto. + (CODE_FOR_lasx_xvsllwil_h_b): Ditto. + (CODE_FOR_lasx_xvsllwil_w_h): Ditto. + (CODE_FOR_lasx_xvsllwil_d_w): Ditto. + (CODE_FOR_lasx_xvsllwil_hu_bu): Ditto. + (CODE_FOR_lasx_xvsllwil_wu_hu): Ditto. + (CODE_FOR_lasx_xvsllwil_du_wu): Ditto. + (CODE_FOR_lasx_xvsat_b): Ditto. + (CODE_FOR_lasx_xvsat_h): Ditto. + (CODE_FOR_lasx_xvsat_w): Ditto. + (CODE_FOR_lasx_xvsat_d): Ditto. + (CODE_FOR_lasx_xvsat_bu): Ditto. + (CODE_FOR_lasx_xvsat_hu): Ditto. + (CODE_FOR_lasx_xvsat_wu): Ditto. + (CODE_FOR_lasx_xvsat_du): Ditto. + (loongarch_builtin_vectorized_function): Ditto. + (loongarch_expand_builtin_insn): Ditto. + (loongarch_expand_builtin): Ditto. + * config/loongarch/loongarch-ftypes.def (1): Ditto. + (2): Ditto. + (3): Ditto. + (4): Ditto. + * config/loongarch/lasxintrin.h: New file. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config.gcc | 2 +- + gcc/config/loongarch/lasxintrin.h | 5338 ++++++++++++++++++++ + gcc/config/loongarch/loongarch-builtins.cc | 1180 ++++- + gcc/config/loongarch/loongarch-ftypes.def | 271 +- + 4 files changed, 6788 insertions(+), 3 deletions(-) + create mode 100644 gcc/config/loongarch/lasxintrin.h + +diff --git a/gcc/config.gcc b/gcc/config.gcc +index 4e149e0ef..19f584344 100644 +--- a/gcc/config.gcc ++++ b/gcc/config.gcc +@@ -456,7 +456,7 @@ mips*-*-*) + ;; + loongarch*-*-*) + cpu_type=loongarch +- extra_headers="larchintrin.h lsxintrin.h" ++ extra_headers="larchintrin.h lsxintrin.h lasxintrin.h" + extra_objs="loongarch-c.o loongarch-builtins.o loongarch-cpu.o loongarch-opts.o loongarch-def.o" + extra_gcc_objs="loongarch-driver.o loongarch-cpu.o loongarch-opts.o loongarch-def.o" + extra_options="${extra_options} g.opt fused-madd.opt" +diff --git a/gcc/config/loongarch/lasxintrin.h b/gcc/config/loongarch/lasxintrin.h +new file mode 100644 +index 000000000..d39379927 +--- /dev/null ++++ b/gcc/config/loongarch/lasxintrin.h +@@ -0,0 +1,5338 @@ ++/* LARCH Loongson ASX intrinsics include file. ++ ++ Copyright (C) 2018 Free Software Foundation, Inc. ++ ++ This file is part of GCC. ++ ++ GCC is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published ++ by the Free Software Foundation; either version 3, or (at your ++ option) any later version. ++ ++ GCC is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ Under Section 7 of GPL version 3, you are granted additional ++ permissions described in the GCC Runtime Library Exception, version ++ 3.1, as published by the Free Software Foundation. ++ ++ You should have received a copy of the GNU General Public License and ++ a copy of the GCC Runtime Library Exception along with this program; ++ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see ++ <http://www.gnu.org/licenses/>. */ ++ ++#ifndef _GCC_LOONGSON_ASXINTRIN_H ++#define _GCC_LOONGSON_ASXINTRIN_H 1 ++ ++#if defined(__loongarch_asx) ++ ++typedef signed char v32i8 __attribute__ ((vector_size(32), aligned(32))); ++typedef signed char v32i8_b __attribute__ ((vector_size(32), aligned(1))); ++typedef unsigned char v32u8 __attribute__ ((vector_size(32), aligned(32))); ++typedef unsigned char v32u8_b __attribute__ ((vector_size(32), aligned(1))); ++typedef short v16i16 __attribute__ ((vector_size(32), aligned(32))); ++typedef short v16i16_h __attribute__ ((vector_size(32), aligned(2))); ++typedef unsigned short v16u16 __attribute__ ((vector_size(32), aligned(32))); ++typedef unsigned short v16u16_h __attribute__ ((vector_size(32), aligned(2))); ++typedef int v8i32 __attribute__ ((vector_size(32), aligned(32))); ++typedef int v8i32_w __attribute__ ((vector_size(32), aligned(4))); ++typedef unsigned int v8u32 __attribute__ ((vector_size(32), aligned(32))); ++typedef unsigned int v8u32_w __attribute__ ((vector_size(32), aligned(4))); ++typedef long long v4i64 __attribute__ ((vector_size(32), aligned(32))); ++typedef long long v4i64_d __attribute__ ((vector_size(32), aligned(8))); ++typedef unsigned long long v4u64 __attribute__ ((vector_size(32), aligned(32))); ++typedef unsigned long long v4u64_d __attribute__ ((vector_size(32), aligned(8))); ++typedef float v8f32 __attribute__ ((vector_size(32), aligned(32))); ++typedef float v8f32_w __attribute__ ((vector_size(32), aligned(4))); ++typedef double v4f64 __attribute__ ((vector_size(32), aligned(32))); ++typedef double v4f64_d __attribute__ ((vector_size(32), aligned(8))); ++typedef float __m256 __attribute__ ((__vector_size__ (32), ++ __may_alias__)); ++typedef long long __m256i __attribute__ ((__vector_size__ (32), ++ __may_alias__)); ++typedef double __m256d __attribute__ ((__vector_size__ (32), ++ __may_alias__)); ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsll_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsll_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsll_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsll_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsll_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsll_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsll_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsll_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvslli_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslli_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvslli_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslli_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvslli_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslli_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvslli_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslli_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsra_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsra_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsra_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsra_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsra_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsra_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsra_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsra_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvsrai_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrai_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvsrai_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrai_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvsrai_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrai_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvsrai_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrai_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrar_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrar_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrar_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrar_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrar_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrar_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrar_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrar_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvsrari_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrari_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvsrari_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrari_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvsrari_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrari_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvsrari_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrari_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrl_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrl_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrl_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrl_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrl_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrl_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrl_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrl_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvsrli_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrli_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvsrli_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrli_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvsrli_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrli_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvsrli_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrli_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrlr_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrlr_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrlr_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrlr_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrlr_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrlr_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrlr_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrlr_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvsrlri_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrlri_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvsrlri_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrlri_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvsrlri_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrlri_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvsrlri_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsrlri_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitclr_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitclr_b ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitclr_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitclr_h ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitclr_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitclr_w ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitclr_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitclr_d ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvbitclri_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitclri_b ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UQI. */ ++#define __lasx_xvbitclri_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitclri_h ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UQI. */ ++#define __lasx_xvbitclri_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitclri_w ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UQI. */ ++#define __lasx_xvbitclri_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitclri_d ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitset_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitset_b ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitset_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitset_h ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitset_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitset_w ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitset_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitset_d ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvbitseti_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitseti_b ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UQI. */ ++#define __lasx_xvbitseti_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitseti_h ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UQI. */ ++#define __lasx_xvbitseti_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitseti_w ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UQI. */ ++#define __lasx_xvbitseti_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitseti_d ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitrev_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitrev_b ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitrev_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitrev_h ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitrev_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitrev_w ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitrev_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvbitrev_d ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvbitrevi_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitrevi_b ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UQI. */ ++#define __lasx_xvbitrevi_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitrevi_h ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UQI. */ ++#define __lasx_xvbitrevi_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitrevi_w ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UQI. */ ++#define __lasx_xvbitrevi_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbitrevi_d ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadd_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadd_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadd_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadd_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadd_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadd_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadd_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadd_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvaddi_bu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvaddi_bu ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvaddi_hu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvaddi_hu ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvaddi_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvaddi_wu ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvaddi_du(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvaddi_du ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsub_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsub_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsub_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsub_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsub_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsub_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsub_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsub_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvsubi_bu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsubi_bu ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvsubi_hu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsubi_hu ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvsubi_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsubi_wu ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvsubi_du(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsubi_du ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V32QI, V32QI, QI. */ ++#define __lasx_xvmaxi_b(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V16HI, V16HI, QI. */ ++#define __lasx_xvmaxi_h(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V8SI, V8SI, QI. */ ++#define __lasx_xvmaxi_w(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V4DI, V4DI, QI. */ ++#define __lasx_xvmaxi_d(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmax_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmax_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvmaxi_bu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_bu ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UQI. */ ++#define __lasx_xvmaxi_hu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_hu ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UQI. */ ++#define __lasx_xvmaxi_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_wu ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UQI. */ ++#define __lasx_xvmaxi_du(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmaxi_du ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V32QI, V32QI, QI. */ ++#define __lasx_xvmini_b(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V16HI, V16HI, QI. */ ++#define __lasx_xvmini_h(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V8SI, V8SI, QI. */ ++#define __lasx_xvmini_w(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V4DI, V4DI, QI. */ ++#define __lasx_xvmini_d(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmin_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmin_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvmini_bu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_bu ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UQI. */ ++#define __lasx_xvmini_hu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_hu ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UQI. */ ++#define __lasx_xvmini_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_wu ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UQI. */ ++#define __lasx_xvmini_du(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvmini_du ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvseq_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvseq_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvseq_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvseq_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvseq_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvseq_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvseq_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvseq_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V32QI, V32QI, QI. */ ++#define __lasx_xvseqi_b(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvseqi_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V16HI, V16HI, QI. */ ++#define __lasx_xvseqi_h(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvseqi_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V8SI, V8SI, QI. */ ++#define __lasx_xvseqi_w(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvseqi_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V4DI, V4DI, QI. */ ++#define __lasx_xvseqi_d(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvseqi_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V32QI, V32QI, QI. */ ++#define __lasx_xvslti_b(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V16HI, V16HI, QI. */ ++#define __lasx_xvslti_h(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V8SI, V8SI, QI. */ ++#define __lasx_xvslti_w(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V4DI, V4DI, QI. */ ++#define __lasx_xvslti_d(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvslt_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvslt_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V32QI, UV32QI, UQI. */ ++#define __lasx_xvslti_bu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_bu ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, UV16HI, UQI. */ ++#define __lasx_xvslti_hu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_hu ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, UV8SI, UQI. */ ++#define __lasx_xvslti_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_wu ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V4DI, UV4DI, UQI. */ ++#define __lasx_xvslti_du(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslti_du ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V32QI, V32QI, QI. */ ++#define __lasx_xvslei_b(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V16HI, V16HI, QI. */ ++#define __lasx_xvslei_h(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V8SI, V8SI, QI. */ ++#define __lasx_xvslei_w(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, si5. */ ++/* Data types in instruction templates: V4DI, V4DI, QI. */ ++#define __lasx_xvslei_d(/*__m256i*/ _1, /*si5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsle_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsle_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V32QI, UV32QI, UQI. */ ++#define __lasx_xvslei_bu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_bu ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, UV16HI, UQI. */ ++#define __lasx_xvslei_hu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_hu ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, UV8SI, UQI. */ ++#define __lasx_xvslei_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_wu ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V4DI, UV4DI, UQI. */ ++#define __lasx_xvslei_du(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvslei_du ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvsat_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvsat_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvsat_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvsat_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvsat_bu(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_bu ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UQI. */ ++#define __lasx_xvsat_hu(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_hu ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UQI. */ ++#define __lasx_xvsat_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_wu ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UQI. */ ++#define __lasx_xvsat_du(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsat_du ((v4u64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadda_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadda_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadda_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadda_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadda_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadda_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadda_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadda_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsadd_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsadd_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavg_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavg_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvavgr_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvavgr_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssub_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssub_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvabsd_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvabsd_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmul_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmul_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmul_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmul_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmul_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmul_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmul_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmul_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmadd_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmadd_b ((v32i8)_1, (v32i8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmadd_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmadd_h ((v16i16)_1, (v16i16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmadd_w (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmadd_w ((v8i32)_1, (v8i32)_2, (v8i32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmadd_d (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmadd_d ((v4i64)_1, (v4i64)_2, (v4i64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmsub_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmsub_b ((v32i8)_1, (v32i8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmsub_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmsub_h ((v16i16)_1, (v16i16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmsub_w (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmsub_w ((v8i32)_1, (v8i32)_2, (v8i32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmsub_d (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmsub_d ((v4i64)_1, (v4i64)_2, (v4i64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvdiv_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvdiv_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_hu_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_hu_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_wu_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_wu_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_du_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_du_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_hu_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_hu_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_wu_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_wu_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_du_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_du_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmod_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmod_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvrepl128vei_b(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrepl128vei_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvrepl128vei_h(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrepl128vei_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui2. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvrepl128vei_w(/*__m256i*/ _1, /*ui2*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrepl128vei_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui1. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvrepl128vei_d(/*__m256i*/ _1, /*ui1*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrepl128vei_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickev_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickev_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickev_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickev_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickev_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickev_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickev_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickev_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickod_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickod_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickod_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickod_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickod_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickod_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpickod_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpickod_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvh_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvh_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvh_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvh_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvh_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvh_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvh_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvh_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvl_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvl_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvl_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvl_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvl_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvl_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvilvl_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvilvl_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackev_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackev_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackev_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackev_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackev_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackev_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackev_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackev_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackod_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackod_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackod_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackod_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackod_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackod_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpackod_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvpackod_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvshuf_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvshuf_b ((v32i8)_1, (v32i8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvshuf_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvshuf_h ((v16i16)_1, (v16i16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvshuf_w (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvshuf_w ((v8i32)_1, (v8i32)_2, (v8i32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvshuf_d (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvshuf_d ((v4i64)_1, (v4i64)_2, (v4i64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvand_v (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvand_v ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvandi_b(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvandi_b ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvor_v (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvor_v ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvori_b(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvori_b ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvnor_v (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvnor_v ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvnori_b(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvnori_b ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvxor_v (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvxor_v ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UQI. */ ++#define __lasx_xvxori_b(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvxori_b ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvbitsel_v (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvbitsel_v ((v32u8)_1, (v32u8)_2, (v32u8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI, USI. */ ++#define __lasx_xvbitseli_b(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvbitseli_b ((v32u8)(_1), (v32u8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V32QI, V32QI, USI. */ ++#define __lasx_xvshuf4i_b(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvshuf4i_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V16HI, V16HI, USI. */ ++#define __lasx_xvshuf4i_h(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvshuf4i_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V8SI, V8SI, USI. */ ++#define __lasx_xvshuf4i_w(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvshuf4i_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, rj. */ ++/* Data types in instruction templates: V32QI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplgr2vr_b (int _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplgr2vr_b ((int)_1); ++} ++ ++/* Assembly instruction format: xd, rj. */ ++/* Data types in instruction templates: V16HI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplgr2vr_h (int _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplgr2vr_h ((int)_1); ++} ++ ++/* Assembly instruction format: xd, rj. */ ++/* Data types in instruction templates: V8SI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplgr2vr_w (int _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplgr2vr_w ((int)_1); ++} ++ ++/* Assembly instruction format: xd, rj. */ ++/* Data types in instruction templates: V4DI, DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplgr2vr_d (long int _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplgr2vr_d ((long int)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpcnt_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvpcnt_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpcnt_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvpcnt_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpcnt_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvpcnt_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvpcnt_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvpcnt_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclo_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclo_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclo_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclo_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclo_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclo_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclo_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclo_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclz_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclz_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclz_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclz_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclz_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclz_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvclz_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvclz_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfadd_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfadd_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfadd_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfadd_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfsub_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfsub_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfsub_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfsub_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfmul_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfmul_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfmul_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfmul_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfdiv_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfdiv_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfdiv_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfdiv_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcvt_h_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcvt_h_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfcvt_s_d (__m256d _1, __m256d _2) ++{ ++ return (__m256)__builtin_lasx_xvfcvt_s_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfmin_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfmin_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfmin_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfmin_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfmina_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfmina_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfmina_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfmina_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfmax_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfmax_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfmax_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfmax_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfmaxa_s (__m256 _1, __m256 _2) ++{ ++ return (__m256)__builtin_lasx_xvfmaxa_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfmaxa_d (__m256d _1, __m256d _2) ++{ ++ return (__m256d)__builtin_lasx_xvfmaxa_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfclass_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvfclass_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfclass_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvfclass_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfsqrt_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfsqrt_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfsqrt_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfsqrt_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfrecip_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfrecip_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfrecip_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfrecip_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfrint_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfrint_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfrint_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfrint_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfrsqrt_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfrsqrt_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfrsqrt_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfrsqrt_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvflogb_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvflogb_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvflogb_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvflogb_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfcvth_s_h (__m256i _1) ++{ ++ return (__m256)__builtin_lasx_xvfcvth_s_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfcvth_d_s (__m256 _1) ++{ ++ return (__m256d)__builtin_lasx_xvfcvth_d_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfcvtl_s_h (__m256i _1) ++{ ++ return (__m256)__builtin_lasx_xvfcvtl_s_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfcvtl_d_s (__m256 _1) ++{ ++ return (__m256d)__builtin_lasx_xvfcvtl_d_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftint_w_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftint_w_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftint_l_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvftint_l_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftint_wu_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftint_wu_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftint_lu_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvftint_lu_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrz_w_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrz_w_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrz_l_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrz_l_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrz_wu_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrz_wu_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrz_lu_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrz_lu_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvffint_s_w (__m256i _1) ++{ ++ return (__m256)__builtin_lasx_xvffint_s_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvffint_d_l (__m256i _1) ++{ ++ return (__m256d)__builtin_lasx_xvffint_d_l ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SF, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvffint_s_wu (__m256i _1) ++{ ++ return (__m256)__builtin_lasx_xvffint_s_wu ((v8u32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvffint_d_lu (__m256i _1) ++{ ++ return (__m256d)__builtin_lasx_xvffint_d_lu ((v4u64)_1); ++} ++ ++/* Assembly instruction format: xd, xj, rk. */ ++/* Data types in instruction templates: V32QI, V32QI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve_b (__m256i _1, int _2) ++{ ++ return (__m256i)__builtin_lasx_xvreplve_b ((v32i8)_1, (int)_2); ++} ++ ++/* Assembly instruction format: xd, xj, rk. */ ++/* Data types in instruction templates: V16HI, V16HI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve_h (__m256i _1, int _2) ++{ ++ return (__m256i)__builtin_lasx_xvreplve_h ((v16i16)_1, (int)_2); ++} ++ ++/* Assembly instruction format: xd, xj, rk. */ ++/* Data types in instruction templates: V8SI, V8SI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve_w (__m256i _1, int _2) ++{ ++ return (__m256i)__builtin_lasx_xvreplve_w ((v8i32)_1, (int)_2); ++} ++ ++/* Assembly instruction format: xd, xj, rk. */ ++/* Data types in instruction templates: V4DI, V4DI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve_d (__m256i _1, int _2) ++{ ++ return (__m256i)__builtin_lasx_xvreplve_d ((v4i64)_1, (int)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvpermi_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvpermi_w ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvandn_v (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvandn_v ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvneg_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvneg_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvneg_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvneg_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvneg_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvneg_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvneg_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvneg_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmuh_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmuh_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V16HI, V32QI, UQI. */ ++#define __lasx_xvsllwil_h_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsllwil_h_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V8SI, V16HI, UQI. */ ++#define __lasx_xvsllwil_w_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsllwil_w_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V4DI, V8SI, UQI. */ ++#define __lasx_xvsllwil_d_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsllwil_d_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: UV16HI, UV32QI, UQI. */ ++#define __lasx_xvsllwil_hu_bu(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsllwil_hu_bu ((v32u8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV8SI, UV16HI, UQI. */ ++#define __lasx_xvsllwil_wu_hu(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsllwil_wu_hu ((v16u16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV4DI, UV8SI, UQI. */ ++#define __lasx_xvsllwil_du_wu(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvsllwil_du_wu ((v8u32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsran_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsran_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsran_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsran_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsran_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsran_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssran_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssran_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssran_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssran_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssran_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssran_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssran_bu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssran_bu_h ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssran_hu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssran_hu_w ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssran_wu_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssran_wu_d ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrarn_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrarn_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrarn_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrarn_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrarn_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrarn_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrarn_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrarn_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrarn_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrarn_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrarn_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrarn_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrarn_bu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrarn_bu_h ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrarn_hu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrarn_hu_w ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrarn_wu_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrarn_wu_d ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrln_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrln_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrln_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrln_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrln_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrln_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrln_bu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrln_bu_h ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrln_hu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrln_hu_w ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrln_wu_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrln_wu_d ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrlrn_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrlrn_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrlrn_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrlrn_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsrlrn_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsrlrn_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV32QI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrlrn_bu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrlrn_bu_h ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrlrn_hu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrlrn_hu_w ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrlrn_wu_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrlrn_wu_d ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, UQI. */ ++#define __lasx_xvfrstpi_b(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvfrstpi_b ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, UQI. */ ++#define __lasx_xvfrstpi_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvfrstpi_h ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfrstp_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvfrstp_b ((v32i8)_1, (v32i8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfrstp_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvfrstp_h ((v16i16)_1, (v16i16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvshuf4i_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvshuf4i_d ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvbsrl_v(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbsrl_v ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvbsll_v(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvbsll_v ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvextrins_b(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvextrins_b ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvextrins_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvextrins_h ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvextrins_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvextrins_w ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvextrins_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvextrins_d ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmskltz_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvmskltz_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmskltz_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvmskltz_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmskltz_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvmskltz_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmskltz_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvmskltz_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsigncov_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsigncov_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsigncov_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsigncov_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsigncov_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsigncov_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsigncov_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsigncov_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfmadd_s (__m256 _1, __m256 _2, __m256 _3) ++{ ++ return (__m256)__builtin_lasx_xvfmadd_s ((v8f32)_1, (v8f32)_2, (v8f32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfmadd_d (__m256d _1, __m256d _2, __m256d _3) ++{ ++ return (__m256d)__builtin_lasx_xvfmadd_d ((v4f64)_1, (v4f64)_2, (v4f64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfmsub_s (__m256 _1, __m256 _2, __m256 _3) ++{ ++ return (__m256)__builtin_lasx_xvfmsub_s ((v8f32)_1, (v8f32)_2, (v8f32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfmsub_d (__m256d _1, __m256d _2, __m256d _3) ++{ ++ return (__m256d)__builtin_lasx_xvfmsub_d ((v4f64)_1, (v4f64)_2, (v4f64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfnmadd_s (__m256 _1, __m256 _2, __m256 _3) ++{ ++ return (__m256)__builtin_lasx_xvfnmadd_s ((v8f32)_1, (v8f32)_2, (v8f32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfnmadd_d (__m256d _1, __m256d _2, __m256d _3) ++{ ++ return (__m256d)__builtin_lasx_xvfnmadd_d ((v4f64)_1, (v4f64)_2, (v4f64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V8SF, V8SF, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfnmsub_s (__m256 _1, __m256 _2, __m256 _3) ++{ ++ return (__m256)__builtin_lasx_xvfnmsub_s ((v8f32)_1, (v8f32)_2, (v8f32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk, xa. */ ++/* Data types in instruction templates: V4DF, V4DF, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfnmsub_d (__m256d _1, __m256d _2, __m256d _3) ++{ ++ return (__m256d)__builtin_lasx_xvfnmsub_d ((v4f64)_1, (v4f64)_2, (v4f64)_3); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrne_w_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrne_w_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrne_l_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrne_l_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrp_w_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrp_w_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrp_l_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrp_l_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrm_w_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrm_w_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrm_l_d (__m256d _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrm_l_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftint_w_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvftint_w_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SF, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvffint_s_l (__m256i _1, __m256i _2) ++{ ++ return (__m256)__builtin_lasx_xvffint_s_l ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrz_w_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvftintrz_w_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrp_w_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvftintrp_w_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrm_w_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvftintrm_w_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrne_w_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvftintrne_w_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftinth_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftinth_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintl_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintl_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvffinth_d_w (__m256i _1) ++{ ++ return (__m256d)__builtin_lasx_xvffinth_d_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DF, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvffintl_d_w (__m256i _1) ++{ ++ return (__m256d)__builtin_lasx_xvffintl_d_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrzh_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrzh_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrzl_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrzl_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrph_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrph_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrpl_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrpl_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrmh_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrmh_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrml_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrml_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrneh_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrneh_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvftintrnel_l_s (__m256 _1) ++{ ++ return (__m256i)__builtin_lasx_xvftintrnel_l_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfrintrne_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfrintrne_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfrintrne_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfrintrne_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfrintrz_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfrintrz_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfrintrz_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfrintrz_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfrintrp_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfrintrp_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfrintrp_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfrintrp_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256 __lasx_xvfrintrm_s (__m256 _1) ++{ ++ return (__m256)__builtin_lasx_xvfrintrm_s ((v8f32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256d __lasx_xvfrintrm_d (__m256d _1) ++{ ++ return (__m256d)__builtin_lasx_xvfrintrm_d ((v4f64)_1); ++} ++ ++/* Assembly instruction format: xd, rj, si12. */ ++/* Data types in instruction templates: V32QI, CVPOINTER, SI. */ ++#define __lasx_xvld(/*void **/ _1, /*si12*/ _2) \ ++ ((__m256i)__builtin_lasx_xvld ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: xd, rj, si12. */ ++/* Data types in instruction templates: VOID, V32QI, CVPOINTER, SI. */ ++#define __lasx_xvst(/*__m256i*/ _1, /*void **/ _2, /*si12*/ _3) \ ++ ((void)__builtin_lasx_xvst ((v32i8)(_1), (void *)(_2), (_3))) ++ ++/* Assembly instruction format: xd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V32QI, CVPOINTER, SI, UQI. */ ++#define __lasx_xvstelm_b(/*__m256i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lasx_xvstelm_b ((v32i8)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: xd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V16HI, CVPOINTER, SI, UQI. */ ++#define __lasx_xvstelm_h(/*__m256i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lasx_xvstelm_h ((v16i16)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: xd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V8SI, CVPOINTER, SI, UQI. */ ++#define __lasx_xvstelm_w(/*__m256i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lasx_xvstelm_w ((v8i32)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: xd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V4DI, CVPOINTER, SI, UQI. */ ++#define __lasx_xvstelm_d(/*__m256i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lasx_xvstelm_d ((v4i64)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, UQI. */ ++#define __lasx_xvinsve0_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui3*/ _3) \ ++ ((__m256i)__builtin_lasx_xvinsve0_w ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui2. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, UQI. */ ++#define __lasx_xvinsve0_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui2*/ _3) \ ++ ((__m256i)__builtin_lasx_xvinsve0_d ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvpickve_w(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvpickve_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui2. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvpickve_d(/*__m256i*/ _1, /*ui2*/ _2) \ ++ ((__m256i)__builtin_lasx_xvpickve_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrlrn_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrlrn_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrlrn_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrlrn_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrlrn_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrlrn_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrln_b_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrln_b_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrln_h_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrln_h_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvssrln_w_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvssrln_w_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvorn_v (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvorn_v ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, i13. */ ++/* Data types in instruction templates: V4DI, HI. */ ++#define __lasx_xvldi(/*i13*/ _1) \ ++ ((__m256i)__builtin_lasx_xvldi ((_1))) ++ ++/* Assembly instruction format: xd, rj, rk. */ ++/* Data types in instruction templates: V32QI, CVPOINTER, DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvldx (void * _1, long int _2) ++{ ++ return (__m256i)__builtin_lasx_xvldx ((void *)_1, (long int)_2); ++} ++ ++/* Assembly instruction format: xd, rj, rk. */ ++/* Data types in instruction templates: VOID, V32QI, CVPOINTER, DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++void __lasx_xvstx (__m256i _1, void * _2, long int _3) ++{ ++ return (void)__builtin_lasx_xvstx ((v32i8)_1, (void *)_2, (long int)_3); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvextl_qu_du (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvextl_qu_du ((v4u64)_1); ++} ++ ++/* Assembly instruction format: xd, rj, ui3. */ ++/* Data types in instruction templates: V8SI, V8SI, SI, UQI. */ ++#define __lasx_xvinsgr2vr_w(/*__m256i*/ _1, /*int*/ _2, /*ui3*/ _3) \ ++ ((__m256i)__builtin_lasx_xvinsgr2vr_w ((v8i32)(_1), (int)(_2), (_3))) ++ ++/* Assembly instruction format: xd, rj, ui2. */ ++/* Data types in instruction templates: V4DI, V4DI, DI, UQI. */ ++#define __lasx_xvinsgr2vr_d(/*__m256i*/ _1, /*long int*/ _2, /*ui2*/ _3) \ ++ ((__m256i)__builtin_lasx_xvinsgr2vr_d ((v4i64)(_1), (long int)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve0_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplve0_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve0_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplve0_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve0_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplve0_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve0_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplve0_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvreplve0_q (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvreplve0_q ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_h_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_h_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_w_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_w_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_d_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_d_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_w_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_w_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_d_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_d_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_d_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_d_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_hu_bu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_hu_bu ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_wu_hu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_wu_hu ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_du_wu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_du_wu ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_wu_bu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_wu_bu ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_du_hu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_du_hu ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_vext2xv_du_bu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_vext2xv_du_bu ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvpermi_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui8*/ _3) \ ++ ((__m256i)__builtin_lasx_xvpermi_q ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui8. */ ++/* Data types in instruction templates: V4DI, V4DI, USI. */ ++#define __lasx_xvpermi_d(/*__m256i*/ _1, /*ui8*/ _2) \ ++ ((__m256i)__builtin_lasx_xvpermi_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvperm_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvperm_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, rj, si12. */ ++/* Data types in instruction templates: V32QI, CVPOINTER, SI. */ ++#define __lasx_xvldrepl_b(/*void **/ _1, /*si12*/ _2) \ ++ ((__m256i)__builtin_lasx_xvldrepl_b ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: xd, rj, si11. */ ++/* Data types in instruction templates: V16HI, CVPOINTER, SI. */ ++#define __lasx_xvldrepl_h(/*void **/ _1, /*si11*/ _2) \ ++ ((__m256i)__builtin_lasx_xvldrepl_h ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: xd, rj, si10. */ ++/* Data types in instruction templates: V8SI, CVPOINTER, SI. */ ++#define __lasx_xvldrepl_w(/*void **/ _1, /*si10*/ _2) \ ++ ((__m256i)__builtin_lasx_xvldrepl_w ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: xd, rj, si9. */ ++/* Data types in instruction templates: V4DI, CVPOINTER, SI. */ ++#define __lasx_xvldrepl_d(/*void **/ _1, /*si9*/ _2) \ ++ ((__m256i)__builtin_lasx_xvldrepl_d ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: rd, xj, ui3. */ ++/* Data types in instruction templates: SI, V8SI, UQI. */ ++#define __lasx_xvpickve2gr_w(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((int)__builtin_lasx_xvpickve2gr_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: rd, xj, ui3. */ ++/* Data types in instruction templates: USI, V8SI, UQI. */ ++#define __lasx_xvpickve2gr_wu(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((unsigned int)__builtin_lasx_xvpickve2gr_wu ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: rd, xj, ui2. */ ++/* Data types in instruction templates: DI, V4DI, UQI. */ ++#define __lasx_xvpickve2gr_d(/*__m256i*/ _1, /*ui2*/ _2) \ ++ ((long int)__builtin_lasx_xvpickve2gr_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: rd, xj, ui2. */ ++/* Data types in instruction templates: UDI, V4DI, UQI. */ ++#define __lasx_xvpickve2gr_du(/*__m256i*/ _1, /*ui2*/ _2) \ ++ ((unsigned long int)__builtin_lasx_xvpickve2gr_du ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_q_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_q_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_d_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_d_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_w_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_w_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_h_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_h_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_q_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_q_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_d_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_d_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_w_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_w_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwev_h_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwev_h_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_q_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_q_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_d_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_d_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_w_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_w_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_h_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_h_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_q_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_q_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_d_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_d_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_w_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_w_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_h_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_h_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_q_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_q_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_d_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_d_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_w_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_w_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsubwod_h_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsubwod_h_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_d_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_d_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_w_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_w_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_h_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_h_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_q_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_q_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_d_wu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_d_wu ((v8u32)_1, (v8u32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_w_hu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_w_hu ((v16u16)_1, (v16u16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_h_bu (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_h_bu ((v32u8)_1, (v32u8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_d_wu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_d_wu_w ((v8u32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_w_hu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_w_hu_h ((v16u16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_h_bu_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_h_bu_b ((v32u8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_d_wu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_d_wu_w ((v8u32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_w_hu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_w_hu_h ((v16u16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_h_bu_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_h_bu_b ((v32u8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_d_wu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_d_wu_w ((v8u32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_w_hu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_w_hu_h ((v16u16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_h_bu_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_h_bu_b ((v32u8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_d_wu_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_d_wu_w ((v8u32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, UV16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_w_hu_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_w_hu_h ((v16u16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, UV32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_h_bu_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_h_bu_b ((v32u8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhaddw_qu_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhaddw_qu_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_q_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_q_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvhsubw_qu_du (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvhsubw_qu_du ((v4u64)_1, (v4u64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_q_d (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_q_d ((v4i64)_1, (v4i64)_2, (v4i64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_d_w (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_d_w ((v4i64)_1, (v8i32)_2, (v8i32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_w_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_w_h ((v8i32)_1, (v16i16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_h_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_h_b ((v16i16)_1, (v32i8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_q_du (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_q_du ((v4u64)_1, (v4u64)_2, (v4u64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_d_wu (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_d_wu ((v4u64)_1, (v8u32)_2, (v8u32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_w_hu (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_w_hu ((v8u32)_1, (v16u16)_2, (v16u16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_h_bu (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_h_bu ((v16u16)_1, (v32u8)_2, (v32u8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_q_d (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_q_d ((v4i64)_1, (v4i64)_2, (v4i64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_d_w (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_d_w ((v4i64)_1, (v8i32)_2, (v8i32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_w_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_w_h ((v8i32)_1, (v16i16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_h_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_h_b ((v16i16)_1, (v32i8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_q_du (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_q_du ((v4u64)_1, (v4u64)_2, (v4u64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV4DI, UV4DI, UV8SI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_d_wu (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_d_wu ((v4u64)_1, (v8u32)_2, (v8u32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV8SI, UV8SI, UV16HI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_w_hu (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_w_hu ((v8u32)_1, (v16u16)_2, (v16u16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: UV16HI, UV16HI, UV32QI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_h_bu (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_h_bu ((v16u16)_1, (v32u8)_2, (v32u8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, UV4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_q_du_d (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_q_du_d ((v4i64)_1, (v4u64)_2, (v4i64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, UV8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_d_wu_w (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_d_wu_w ((v4i64)_1, (v8u32)_2, (v8i32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, UV16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_w_hu_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_w_hu_h ((v8i32)_1, (v16u16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, UV32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwev_h_bu_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwev_h_bu_b ((v16i16)_1, (v32u8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, UV4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_q_du_d (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_q_du_d ((v4i64)_1, (v4u64)_2, (v4i64)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, UV8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_d_wu_w (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_d_wu_w ((v4i64)_1, (v8u32)_2, (v8i32)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, UV16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_w_hu_h (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_w_hu_h ((v8i32)_1, (v16u16)_2, (v16i16)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, UV32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmaddwod_h_bu_b (__m256i _1, __m256i _2, __m256i _3) ++{ ++ return (__m256i)__builtin_lasx_xvmaddwod_h_bu_b ((v16i16)_1, (v32u8)_2, (v32i8)_3); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvrotr_b (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvrotr_b ((v32i8)_1, (v32i8)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvrotr_h (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvrotr_h ((v16i16)_1, (v16i16)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvrotr_w (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvrotr_w ((v8i32)_1, (v8i32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvrotr_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvrotr_d ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvadd_q (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvadd_q ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvsub_q (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvsub_q ((v4i64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwev_q_du_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwev_q_du_d ((v4u64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvaddwod_q_du_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvaddwod_q_du_d ((v4u64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwev_q_du_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwev_q_du_d ((v4u64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, UV4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmulwod_q_du_d (__m256i _1, __m256i _2) ++{ ++ return (__m256i)__builtin_lasx_xvmulwod_q_du_d ((v4u64)_1, (v4i64)_2); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmskgez_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvmskgez_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V32QI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvmsknz_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvmsknz_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V16HI, V32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_h_b (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_h_b ((v32i8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V8SI, V16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_w_h (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_w_h ((v16i16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_d_w (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_d_w ((v8i32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_q_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_q_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV16HI, UV32QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_hu_bu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_hu_bu ((v32u8)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV8SI, UV16HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_wu_hu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_wu_hu ((v16u16)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV4DI, UV8SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_du_wu (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_du_wu ((v8u32)_1); ++} ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: UV4DI, UV4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvexth_qu_du (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvexth_qu_du ((v4u64)_1); ++} ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V32QI, V32QI, UQI. */ ++#define __lasx_xvrotri_b(/*__m256i*/ _1, /*ui3*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrotri_b ((v32i8)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V16HI, V16HI, UQI. */ ++#define __lasx_xvrotri_h(/*__m256i*/ _1, /*ui4*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrotri_h ((v16i16)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V8SI, V8SI, UQI. */ ++#define __lasx_xvrotri_w(/*__m256i*/ _1, /*ui5*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrotri_w ((v8i32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V4DI, V4DI, UQI. */ ++#define __lasx_xvrotri_d(/*__m256i*/ _1, /*ui6*/ _2) \ ++ ((__m256i)__builtin_lasx_xvrotri_d ((v4i64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj. */ ++/* Data types in instruction templates: V4DI, V4DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvextl_q_d (__m256i _1) ++{ ++ return (__m256i)__builtin_lasx_xvextl_q_d ((v4i64)_1); ++} ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvsrlni_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlni_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvsrlni_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlni_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvsrlni_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlni_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvsrlni_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlni_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvsrlrni_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlrni_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvsrlrni_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlrni_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvsrlrni_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlrni_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvsrlrni_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrlrni_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvssrlni_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvssrlni_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvssrlni_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvssrlni_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV32QI, UV32QI, V32QI, USI. */ ++#define __lasx_xvssrlni_bu_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_bu_h ((v32u8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV16HI, UV16HI, V16HI, USI. */ ++#define __lasx_xvssrlni_hu_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_hu_w ((v16u16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV8SI, UV8SI, V8SI, USI. */ ++#define __lasx_xvssrlni_wu_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_wu_d ((v8u32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: UV4DI, UV4DI, V4DI, USI. */ ++#define __lasx_xvssrlni_du_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlni_du_q ((v4u64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvssrlrni_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvssrlrni_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvssrlrni_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvssrlrni_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV32QI, UV32QI, V32QI, USI. */ ++#define __lasx_xvssrlrni_bu_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_bu_h ((v32u8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV16HI, UV16HI, V16HI, USI. */ ++#define __lasx_xvssrlrni_hu_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_hu_w ((v16u16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV8SI, UV8SI, V8SI, USI. */ ++#define __lasx_xvssrlrni_wu_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_wu_d ((v8u32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: UV4DI, UV4DI, V4DI, USI. */ ++#define __lasx_xvssrlrni_du_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrlrni_du_q ((v4u64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvsrani_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrani_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvsrani_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrani_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvsrani_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrani_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvsrani_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrani_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvsrarni_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrarni_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvsrarni_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrarni_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvsrarni_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrarni_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvsrarni_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvsrarni_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvssrani_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvssrani_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvssrani_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvssrani_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV32QI, UV32QI, V32QI, USI. */ ++#define __lasx_xvssrani_bu_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_bu_h ((v32u8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV16HI, UV16HI, V16HI, USI. */ ++#define __lasx_xvssrani_hu_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_hu_w ((v16u16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV8SI, UV8SI, V8SI, USI. */ ++#define __lasx_xvssrani_wu_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_wu_d ((v8u32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: UV4DI, UV4DI, V4DI, USI. */ ++#define __lasx_xvssrani_du_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrani_du_q ((v4u64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: V32QI, V32QI, V32QI, USI. */ ++#define __lasx_xvssrarni_b_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_b_h ((v32i8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: V16HI, V16HI, V16HI, USI. */ ++#define __lasx_xvssrarni_h_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_h_w ((v16i16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: V8SI, V8SI, V8SI, USI. */ ++#define __lasx_xvssrarni_w_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_w_d ((v8i32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: V4DI, V4DI, V4DI, USI. */ ++#define __lasx_xvssrarni_d_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_d_q ((v4i64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui4. */ ++/* Data types in instruction templates: UV32QI, UV32QI, V32QI, USI. */ ++#define __lasx_xvssrarni_bu_h(/*__m256i*/ _1, /*__m256i*/ _2, /*ui4*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_bu_h ((v32u8)(_1), (v32i8)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui5. */ ++/* Data types in instruction templates: UV16HI, UV16HI, V16HI, USI. */ ++#define __lasx_xvssrarni_hu_w(/*__m256i*/ _1, /*__m256i*/ _2, /*ui5*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_hu_w ((v16u16)(_1), (v16i16)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui6. */ ++/* Data types in instruction templates: UV8SI, UV8SI, V8SI, USI. */ ++#define __lasx_xvssrarni_wu_d(/*__m256i*/ _1, /*__m256i*/ _2, /*ui6*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_wu_d ((v8u32)(_1), (v8i32)(_2), (_3))) ++ ++/* Assembly instruction format: xd, xj, ui7. */ ++/* Data types in instruction templates: UV4DI, UV4DI, V4DI, USI. */ ++#define __lasx_xvssrarni_du_q(/*__m256i*/ _1, /*__m256i*/ _2, /*ui7*/ _3) \ ++ ((__m256i)__builtin_lasx_xvssrarni_du_q ((v4u64)(_1), (v4i64)(_2), (_3))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV32QI. */ ++#define __lasx_xbnz_b(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbnz_b ((v32u8)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV4DI. */ ++#define __lasx_xbnz_d(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbnz_d ((v4u64)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV16HI. */ ++#define __lasx_xbnz_h(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbnz_h ((v16u16)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV32QI. */ ++#define __lasx_xbnz_v(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbnz_v ((v32u8)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV8SI. */ ++#define __lasx_xbnz_w(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbnz_w ((v8u32)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV32QI. */ ++#define __lasx_xbz_b(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbz_b ((v32u8)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV4DI. */ ++#define __lasx_xbz_d(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbz_d ((v4u64)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV16HI. */ ++#define __lasx_xbz_h(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbz_h ((v16u16)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV32QI. */ ++#define __lasx_xbz_v(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbz_v ((v32u8)(_1))) ++ ++/* Assembly instruction format: cd, xj. */ ++/* Data types in instruction templates: SI, UV8SI. */ ++#define __lasx_xbz_w(/*__m256i*/ _1) \ ++ ((int)__builtin_lasx_xbz_w ((v8u32)(_1))) ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_caf_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_caf_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_caf_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_caf_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_ceq_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_ceq_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_ceq_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_ceq_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cle_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cle_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cle_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cle_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_clt_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_clt_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_clt_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_clt_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cne_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cne_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cne_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cne_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cor_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cor_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cor_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cor_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cueq_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cueq_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cueq_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cueq_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cule_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cule_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cule_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cule_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cult_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cult_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cult_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cult_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cun_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cun_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cune_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cune_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cune_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cune_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_cun_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_cun_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_saf_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_saf_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_saf_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_saf_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_seq_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_seq_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_seq_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_seq_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sle_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sle_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sle_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sle_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_slt_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_slt_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_slt_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_slt_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sne_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sne_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sne_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sne_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sor_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sor_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sor_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sor_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sueq_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sueq_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sueq_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sueq_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sule_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sule_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sule_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sule_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sult_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sult_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sult_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sult_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sun_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sun_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V4DI, V4DF, V4DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sune_d (__m256d _1, __m256d _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sune_d ((v4f64)_1, (v4f64)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sune_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sune_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, xk. */ ++/* Data types in instruction templates: V8SI, V8SF, V8SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m256i __lasx_xvfcmp_sun_s (__m256 _1, __m256 _2) ++{ ++ return (__m256i)__builtin_lasx_xvfcmp_sun_s ((v8f32)_1, (v8f32)_2); ++} ++ ++/* Assembly instruction format: xd, xj, ui2. */ ++/* Data types in instruction templates: V4DF, V4DF, UQI. */ ++#define __lasx_xvpickve_d_f(/*__m256d*/ _1, /*ui2*/ _2) \ ++ ((__m256d)__builtin_lasx_xvpickve_d_f ((v4f64)(_1), (_2))) ++ ++/* Assembly instruction format: xd, xj, ui3. */ ++/* Data types in instruction templates: V8SF, V8SF, UQI. */ ++#define __lasx_xvpickve_w_f(/*__m256*/ _1, /*ui3*/ _2) \ ++ ((__m256)__builtin_lasx_xvpickve_w_f ((v8f32)(_1), (_2))) ++ ++/* Assembly instruction format: xd, si10. */ ++/* Data types in instruction templates: V32QI, HI. */ ++#define __lasx_xvrepli_b(/*si10*/ _1) \ ++ ((__m256i)__builtin_lasx_xvrepli_b ((_1))) ++ ++/* Assembly instruction format: xd, si10. */ ++/* Data types in instruction templates: V4DI, HI. */ ++#define __lasx_xvrepli_d(/*si10*/ _1) \ ++ ((__m256i)__builtin_lasx_xvrepli_d ((_1))) ++ ++/* Assembly instruction format: xd, si10. */ ++/* Data types in instruction templates: V16HI, HI. */ ++#define __lasx_xvrepli_h(/*si10*/ _1) \ ++ ((__m256i)__builtin_lasx_xvrepli_h ((_1))) ++ ++/* Assembly instruction format: xd, si10. */ ++/* Data types in instruction templates: V8SI, HI. */ ++#define __lasx_xvrepli_w(/*si10*/ _1) \ ++ ((__m256i)__builtin_lasx_xvrepli_w ((_1))) ++ ++#endif /* defined(__loongarch_asx). */ ++#endif /* _GCC_LOONGSON_ASXINTRIN_H. */ +diff --git a/gcc/config/loongarch/loongarch-builtins.cc b/gcc/config/loongarch/loongarch-builtins.cc +index de6428ac6..a4a7dbec9 100644 +--- a/gcc/config/loongarch/loongarch-builtins.cc ++++ b/gcc/config/loongarch/loongarch-builtins.cc +@@ -74,6 +74,13 @@ enum loongarch_builtin_type + /* The function corresponds to an LSX conditional branch instruction + combined with a compare instruction. */ + LARCH_BUILTIN_LSX_TEST_BRANCH, ++ ++ /* For generating LoongArch LASX. */ ++ LARCH_BUILTIN_LASX, ++ ++ /* The function corresponds to an LASX conditional branch instruction ++ combined with a compare instruction. */ ++ LARCH_BUILTIN_LASX_TEST_BRANCH, + }; + + /* Declare an availability predicate for built-in functions that require +@@ -112,6 +119,7 @@ struct loongarch_builtin_description + + AVAIL_ALL (hard_float, TARGET_HARD_FLOAT_ABI) + AVAIL_ALL (lsx, ISA_HAS_LSX) ++AVAIL_ALL (lasx, ISA_HAS_LASX) + + /* Construct a loongarch_builtin_description from the given arguments. + +@@ -173,6 +181,30 @@ AVAIL_ALL (lsx, ISA_HAS_LSX) + "__builtin_lsx_" #INSN, LARCH_BUILTIN_DIRECT_NO_TARGET, \ + FUNCTION_TYPE, loongarch_builtin_avail_lsx } + ++/* Define an LASX LARCH_BUILTIN_DIRECT function __builtin_lasx_<INSN> ++ for instruction CODE_FOR_lasx_<INSN>. FUNCTION_TYPE is a builtin_description ++ field. */ ++#define LASX_BUILTIN(INSN, FUNCTION_TYPE) \ ++ { CODE_FOR_lasx_ ## INSN, \ ++ "__builtin_lasx_" #INSN, LARCH_BUILTIN_LASX, \ ++ FUNCTION_TYPE, loongarch_builtin_avail_lasx } ++ ++/* Define an LASX LARCH_BUILTIN_DIRECT_NO_TARGET function __builtin_lasx_<INSN> ++ for instruction CODE_FOR_lasx_<INSN>. FUNCTION_TYPE is a builtin_description ++ field. */ ++#define LASX_NO_TARGET_BUILTIN(INSN, FUNCTION_TYPE) \ ++ { CODE_FOR_lasx_ ## INSN, \ ++ "__builtin_lasx_" #INSN, LARCH_BUILTIN_DIRECT_NO_TARGET, \ ++ FUNCTION_TYPE, loongarch_builtin_avail_lasx } ++ ++/* Define an LASX LARCH_BUILTIN_LASX_TEST_BRANCH function __builtin_lasx_<INSN> ++ for instruction CODE_FOR_lasx_<INSN>. FUNCTION_TYPE is a builtin_description ++ field. */ ++#define LASX_BUILTIN_TEST_BRANCH(INSN, FUNCTION_TYPE) \ ++ { CODE_FOR_lasx_ ## INSN, \ ++ "__builtin_lasx_" #INSN, LARCH_BUILTIN_LASX_TEST_BRANCH, \ ++ FUNCTION_TYPE, loongarch_builtin_avail_lasx } ++ + /* LoongArch SX define CODE_FOR_lsx_xxx */ + #define CODE_FOR_lsx_vsadd_b CODE_FOR_ssaddv16qi3 + #define CODE_FOR_lsx_vsadd_h CODE_FOR_ssaddv8hi3 +@@ -442,6 +474,276 @@ AVAIL_ALL (lsx, ISA_HAS_LSX) + #define CODE_FOR_lsx_vssrlrn_hu_w CODE_FOR_lsx_vssrlrn_u_hu_w + #define CODE_FOR_lsx_vssrlrn_wu_d CODE_FOR_lsx_vssrlrn_u_wu_d + ++/* LoongArch ASX define CODE_FOR_lasx_mxxx */ ++#define CODE_FOR_lasx_xvsadd_b CODE_FOR_ssaddv32qi3 ++#define CODE_FOR_lasx_xvsadd_h CODE_FOR_ssaddv16hi3 ++#define CODE_FOR_lasx_xvsadd_w CODE_FOR_ssaddv8si3 ++#define CODE_FOR_lasx_xvsadd_d CODE_FOR_ssaddv4di3 ++#define CODE_FOR_lasx_xvsadd_bu CODE_FOR_usaddv32qi3 ++#define CODE_FOR_lasx_xvsadd_hu CODE_FOR_usaddv16hi3 ++#define CODE_FOR_lasx_xvsadd_wu CODE_FOR_usaddv8si3 ++#define CODE_FOR_lasx_xvsadd_du CODE_FOR_usaddv4di3 ++#define CODE_FOR_lasx_xvadd_b CODE_FOR_addv32qi3 ++#define CODE_FOR_lasx_xvadd_h CODE_FOR_addv16hi3 ++#define CODE_FOR_lasx_xvadd_w CODE_FOR_addv8si3 ++#define CODE_FOR_lasx_xvadd_d CODE_FOR_addv4di3 ++#define CODE_FOR_lasx_xvaddi_bu CODE_FOR_addv32qi3 ++#define CODE_FOR_lasx_xvaddi_hu CODE_FOR_addv16hi3 ++#define CODE_FOR_lasx_xvaddi_wu CODE_FOR_addv8si3 ++#define CODE_FOR_lasx_xvaddi_du CODE_FOR_addv4di3 ++#define CODE_FOR_lasx_xvand_v CODE_FOR_andv32qi3 ++#define CODE_FOR_lasx_xvandi_b CODE_FOR_andv32qi3 ++#define CODE_FOR_lasx_xvbitsel_v CODE_FOR_lasx_xvbitsel_b ++#define CODE_FOR_lasx_xvseqi_b CODE_FOR_lasx_xvseq_b ++#define CODE_FOR_lasx_xvseqi_h CODE_FOR_lasx_xvseq_h ++#define CODE_FOR_lasx_xvseqi_w CODE_FOR_lasx_xvseq_w ++#define CODE_FOR_lasx_xvseqi_d CODE_FOR_lasx_xvseq_d ++#define CODE_FOR_lasx_xvslti_b CODE_FOR_lasx_xvslt_b ++#define CODE_FOR_lasx_xvslti_h CODE_FOR_lasx_xvslt_h ++#define CODE_FOR_lasx_xvslti_w CODE_FOR_lasx_xvslt_w ++#define CODE_FOR_lasx_xvslti_d CODE_FOR_lasx_xvslt_d ++#define CODE_FOR_lasx_xvslti_bu CODE_FOR_lasx_xvslt_bu ++#define CODE_FOR_lasx_xvslti_hu CODE_FOR_lasx_xvslt_hu ++#define CODE_FOR_lasx_xvslti_wu CODE_FOR_lasx_xvslt_wu ++#define CODE_FOR_lasx_xvslti_du CODE_FOR_lasx_xvslt_du ++#define CODE_FOR_lasx_xvslei_b CODE_FOR_lasx_xvsle_b ++#define CODE_FOR_lasx_xvslei_h CODE_FOR_lasx_xvsle_h ++#define CODE_FOR_lasx_xvslei_w CODE_FOR_lasx_xvsle_w ++#define CODE_FOR_lasx_xvslei_d CODE_FOR_lasx_xvsle_d ++#define CODE_FOR_lasx_xvslei_bu CODE_FOR_lasx_xvsle_bu ++#define CODE_FOR_lasx_xvslei_hu CODE_FOR_lasx_xvsle_hu ++#define CODE_FOR_lasx_xvslei_wu CODE_FOR_lasx_xvsle_wu ++#define CODE_FOR_lasx_xvslei_du CODE_FOR_lasx_xvsle_du ++#define CODE_FOR_lasx_xvdiv_b CODE_FOR_divv32qi3 ++#define CODE_FOR_lasx_xvdiv_h CODE_FOR_divv16hi3 ++#define CODE_FOR_lasx_xvdiv_w CODE_FOR_divv8si3 ++#define CODE_FOR_lasx_xvdiv_d CODE_FOR_divv4di3 ++#define CODE_FOR_lasx_xvdiv_bu CODE_FOR_udivv32qi3 ++#define CODE_FOR_lasx_xvdiv_hu CODE_FOR_udivv16hi3 ++#define CODE_FOR_lasx_xvdiv_wu CODE_FOR_udivv8si3 ++#define CODE_FOR_lasx_xvdiv_du CODE_FOR_udivv4di3 ++#define CODE_FOR_lasx_xvfadd_s CODE_FOR_addv8sf3 ++#define CODE_FOR_lasx_xvfadd_d CODE_FOR_addv4df3 ++#define CODE_FOR_lasx_xvftintrz_w_s CODE_FOR_fix_truncv8sfv8si2 ++#define CODE_FOR_lasx_xvftintrz_l_d CODE_FOR_fix_truncv4dfv4di2 ++#define CODE_FOR_lasx_xvftintrz_wu_s CODE_FOR_fixuns_truncv8sfv8si2 ++#define CODE_FOR_lasx_xvftintrz_lu_d CODE_FOR_fixuns_truncv4dfv4di2 ++#define CODE_FOR_lasx_xvffint_s_w CODE_FOR_floatv8siv8sf2 ++#define CODE_FOR_lasx_xvffint_d_l CODE_FOR_floatv4div4df2 ++#define CODE_FOR_lasx_xvffint_s_wu CODE_FOR_floatunsv8siv8sf2 ++#define CODE_FOR_lasx_xvffint_d_lu CODE_FOR_floatunsv4div4df2 ++#define CODE_FOR_lasx_xvfsub_s CODE_FOR_subv8sf3 ++#define CODE_FOR_lasx_xvfsub_d CODE_FOR_subv4df3 ++#define CODE_FOR_lasx_xvfmul_s CODE_FOR_mulv8sf3 ++#define CODE_FOR_lasx_xvfmul_d CODE_FOR_mulv4df3 ++#define CODE_FOR_lasx_xvfdiv_s CODE_FOR_divv8sf3 ++#define CODE_FOR_lasx_xvfdiv_d CODE_FOR_divv4df3 ++#define CODE_FOR_lasx_xvfmax_s CODE_FOR_smaxv8sf3 ++#define CODE_FOR_lasx_xvfmax_d CODE_FOR_smaxv4df3 ++#define CODE_FOR_lasx_xvfmin_s CODE_FOR_sminv8sf3 ++#define CODE_FOR_lasx_xvfmin_d CODE_FOR_sminv4df3 ++#define CODE_FOR_lasx_xvfsqrt_s CODE_FOR_sqrtv8sf2 ++#define CODE_FOR_lasx_xvfsqrt_d CODE_FOR_sqrtv4df2 ++#define CODE_FOR_lasx_xvflogb_s CODE_FOR_logbv8sf2 ++#define CODE_FOR_lasx_xvflogb_d CODE_FOR_logbv4df2 ++#define CODE_FOR_lasx_xvmax_b CODE_FOR_smaxv32qi3 ++#define CODE_FOR_lasx_xvmax_h CODE_FOR_smaxv16hi3 ++#define CODE_FOR_lasx_xvmax_w CODE_FOR_smaxv8si3 ++#define CODE_FOR_lasx_xvmax_d CODE_FOR_smaxv4di3 ++#define CODE_FOR_lasx_xvmaxi_b CODE_FOR_smaxv32qi3 ++#define CODE_FOR_lasx_xvmaxi_h CODE_FOR_smaxv16hi3 ++#define CODE_FOR_lasx_xvmaxi_w CODE_FOR_smaxv8si3 ++#define CODE_FOR_lasx_xvmaxi_d CODE_FOR_smaxv4di3 ++#define CODE_FOR_lasx_xvmax_bu CODE_FOR_umaxv32qi3 ++#define CODE_FOR_lasx_xvmax_hu CODE_FOR_umaxv16hi3 ++#define CODE_FOR_lasx_xvmax_wu CODE_FOR_umaxv8si3 ++#define CODE_FOR_lasx_xvmax_du CODE_FOR_umaxv4di3 ++#define CODE_FOR_lasx_xvmaxi_bu CODE_FOR_umaxv32qi3 ++#define CODE_FOR_lasx_xvmaxi_hu CODE_FOR_umaxv16hi3 ++#define CODE_FOR_lasx_xvmaxi_wu CODE_FOR_umaxv8si3 ++#define CODE_FOR_lasx_xvmaxi_du CODE_FOR_umaxv4di3 ++#define CODE_FOR_lasx_xvmin_b CODE_FOR_sminv32qi3 ++#define CODE_FOR_lasx_xvmin_h CODE_FOR_sminv16hi3 ++#define CODE_FOR_lasx_xvmin_w CODE_FOR_sminv8si3 ++#define CODE_FOR_lasx_xvmin_d CODE_FOR_sminv4di3 ++#define CODE_FOR_lasx_xvmini_b CODE_FOR_sminv32qi3 ++#define CODE_FOR_lasx_xvmini_h CODE_FOR_sminv16hi3 ++#define CODE_FOR_lasx_xvmini_w CODE_FOR_sminv8si3 ++#define CODE_FOR_lasx_xvmini_d CODE_FOR_sminv4di3 ++#define CODE_FOR_lasx_xvmin_bu CODE_FOR_uminv32qi3 ++#define CODE_FOR_lasx_xvmin_hu CODE_FOR_uminv16hi3 ++#define CODE_FOR_lasx_xvmin_wu CODE_FOR_uminv8si3 ++#define CODE_FOR_lasx_xvmin_du CODE_FOR_uminv4di3 ++#define CODE_FOR_lasx_xvmini_bu CODE_FOR_uminv32qi3 ++#define CODE_FOR_lasx_xvmini_hu CODE_FOR_uminv16hi3 ++#define CODE_FOR_lasx_xvmini_wu CODE_FOR_uminv8si3 ++#define CODE_FOR_lasx_xvmini_du CODE_FOR_uminv4di3 ++#define CODE_FOR_lasx_xvmod_b CODE_FOR_modv32qi3 ++#define CODE_FOR_lasx_xvmod_h CODE_FOR_modv16hi3 ++#define CODE_FOR_lasx_xvmod_w CODE_FOR_modv8si3 ++#define CODE_FOR_lasx_xvmod_d CODE_FOR_modv4di3 ++#define CODE_FOR_lasx_xvmod_bu CODE_FOR_umodv32qi3 ++#define CODE_FOR_lasx_xvmod_hu CODE_FOR_umodv16hi3 ++#define CODE_FOR_lasx_xvmod_wu CODE_FOR_umodv8si3 ++#define CODE_FOR_lasx_xvmod_du CODE_FOR_umodv4di3 ++#define CODE_FOR_lasx_xvmul_b CODE_FOR_mulv32qi3 ++#define CODE_FOR_lasx_xvmul_h CODE_FOR_mulv16hi3 ++#define CODE_FOR_lasx_xvmul_w CODE_FOR_mulv8si3 ++#define CODE_FOR_lasx_xvmul_d CODE_FOR_mulv4di3 ++#define CODE_FOR_lasx_xvclz_b CODE_FOR_clzv32qi2 ++#define CODE_FOR_lasx_xvclz_h CODE_FOR_clzv16hi2 ++#define CODE_FOR_lasx_xvclz_w CODE_FOR_clzv8si2 ++#define CODE_FOR_lasx_xvclz_d CODE_FOR_clzv4di2 ++#define CODE_FOR_lasx_xvnor_v CODE_FOR_lasx_xvnor_b ++#define CODE_FOR_lasx_xvor_v CODE_FOR_iorv32qi3 ++#define CODE_FOR_lasx_xvori_b CODE_FOR_iorv32qi3 ++#define CODE_FOR_lasx_xvnori_b CODE_FOR_lasx_xvnor_b ++#define CODE_FOR_lasx_xvpcnt_b CODE_FOR_popcountv32qi2 ++#define CODE_FOR_lasx_xvpcnt_h CODE_FOR_popcountv16hi2 ++#define CODE_FOR_lasx_xvpcnt_w CODE_FOR_popcountv8si2 ++#define CODE_FOR_lasx_xvpcnt_d CODE_FOR_popcountv4di2 ++#define CODE_FOR_lasx_xvxor_v CODE_FOR_xorv32qi3 ++#define CODE_FOR_lasx_xvxori_b CODE_FOR_xorv32qi3 ++#define CODE_FOR_lasx_xvsll_b CODE_FOR_vashlv32qi3 ++#define CODE_FOR_lasx_xvsll_h CODE_FOR_vashlv16hi3 ++#define CODE_FOR_lasx_xvsll_w CODE_FOR_vashlv8si3 ++#define CODE_FOR_lasx_xvsll_d CODE_FOR_vashlv4di3 ++#define CODE_FOR_lasx_xvslli_b CODE_FOR_vashlv32qi3 ++#define CODE_FOR_lasx_xvslli_h CODE_FOR_vashlv16hi3 ++#define CODE_FOR_lasx_xvslli_w CODE_FOR_vashlv8si3 ++#define CODE_FOR_lasx_xvslli_d CODE_FOR_vashlv4di3 ++#define CODE_FOR_lasx_xvsra_b CODE_FOR_vashrv32qi3 ++#define CODE_FOR_lasx_xvsra_h CODE_FOR_vashrv16hi3 ++#define CODE_FOR_lasx_xvsra_w CODE_FOR_vashrv8si3 ++#define CODE_FOR_lasx_xvsra_d CODE_FOR_vashrv4di3 ++#define CODE_FOR_lasx_xvsrai_b CODE_FOR_vashrv32qi3 ++#define CODE_FOR_lasx_xvsrai_h CODE_FOR_vashrv16hi3 ++#define CODE_FOR_lasx_xvsrai_w CODE_FOR_vashrv8si3 ++#define CODE_FOR_lasx_xvsrai_d CODE_FOR_vashrv4di3 ++#define CODE_FOR_lasx_xvsrl_b CODE_FOR_vlshrv32qi3 ++#define CODE_FOR_lasx_xvsrl_h CODE_FOR_vlshrv16hi3 ++#define CODE_FOR_lasx_xvsrl_w CODE_FOR_vlshrv8si3 ++#define CODE_FOR_lasx_xvsrl_d CODE_FOR_vlshrv4di3 ++#define CODE_FOR_lasx_xvsrli_b CODE_FOR_vlshrv32qi3 ++#define CODE_FOR_lasx_xvsrli_h CODE_FOR_vlshrv16hi3 ++#define CODE_FOR_lasx_xvsrli_w CODE_FOR_vlshrv8si3 ++#define CODE_FOR_lasx_xvsrli_d CODE_FOR_vlshrv4di3 ++#define CODE_FOR_lasx_xvsub_b CODE_FOR_subv32qi3 ++#define CODE_FOR_lasx_xvsub_h CODE_FOR_subv16hi3 ++#define CODE_FOR_lasx_xvsub_w CODE_FOR_subv8si3 ++#define CODE_FOR_lasx_xvsub_d CODE_FOR_subv4di3 ++#define CODE_FOR_lasx_xvsubi_bu CODE_FOR_subv32qi3 ++#define CODE_FOR_lasx_xvsubi_hu CODE_FOR_subv16hi3 ++#define CODE_FOR_lasx_xvsubi_wu CODE_FOR_subv8si3 ++#define CODE_FOR_lasx_xvsubi_du CODE_FOR_subv4di3 ++#define CODE_FOR_lasx_xvpackod_d CODE_FOR_lasx_xvilvh_d ++#define CODE_FOR_lasx_xvpackev_d CODE_FOR_lasx_xvilvl_d ++#define CODE_FOR_lasx_xvpickod_d CODE_FOR_lasx_xvilvh_d ++#define CODE_FOR_lasx_xvpickev_d CODE_FOR_lasx_xvilvl_d ++#define CODE_FOR_lasx_xvrepli_b CODE_FOR_lasx_xvrepliv32qi ++#define CODE_FOR_lasx_xvrepli_h CODE_FOR_lasx_xvrepliv16hi ++#define CODE_FOR_lasx_xvrepli_w CODE_FOR_lasx_xvrepliv8si ++#define CODE_FOR_lasx_xvrepli_d CODE_FOR_lasx_xvrepliv4di ++ ++#define CODE_FOR_lasx_xvandn_v CODE_FOR_xvandnv32qi3 ++#define CODE_FOR_lasx_xvorn_v CODE_FOR_xvornv32qi3 ++#define CODE_FOR_lasx_xvneg_b CODE_FOR_negv32qi2 ++#define CODE_FOR_lasx_xvneg_h CODE_FOR_negv16hi2 ++#define CODE_FOR_lasx_xvneg_w CODE_FOR_negv8si2 ++#define CODE_FOR_lasx_xvneg_d CODE_FOR_negv4di2 ++#define CODE_FOR_lasx_xvbsrl_v CODE_FOR_lasx_xvbsrl_b ++#define CODE_FOR_lasx_xvbsll_v CODE_FOR_lasx_xvbsll_b ++#define CODE_FOR_lasx_xvfmadd_s CODE_FOR_fmav8sf4 ++#define CODE_FOR_lasx_xvfmadd_d CODE_FOR_fmav4df4 ++#define CODE_FOR_lasx_xvfmsub_s CODE_FOR_fmsv8sf4 ++#define CODE_FOR_lasx_xvfmsub_d CODE_FOR_fmsv4df4 ++#define CODE_FOR_lasx_xvfnmadd_s CODE_FOR_xvfnmaddv8sf4_nmadd4 ++#define CODE_FOR_lasx_xvfnmadd_d CODE_FOR_xvfnmaddv4df4_nmadd4 ++#define CODE_FOR_lasx_xvfnmsub_s CODE_FOR_xvfnmsubv8sf4_nmsub4 ++#define CODE_FOR_lasx_xvfnmsub_d CODE_FOR_xvfnmsubv4df4_nmsub4 ++ ++#define CODE_FOR_lasx_xvpermi_q CODE_FOR_lasx_xvpermi_q_v32qi ++#define CODE_FOR_lasx_xvpermi_d CODE_FOR_lasx_xvpermi_d_v4di ++#define CODE_FOR_lasx_xbnz_v CODE_FOR_lasx_xbnz_v_b ++#define CODE_FOR_lasx_xbz_v CODE_FOR_lasx_xbz_v_b ++ ++#define CODE_FOR_lasx_xvssub_b CODE_FOR_lasx_xvssub_s_b ++#define CODE_FOR_lasx_xvssub_h CODE_FOR_lasx_xvssub_s_h ++#define CODE_FOR_lasx_xvssub_w CODE_FOR_lasx_xvssub_s_w ++#define CODE_FOR_lasx_xvssub_d CODE_FOR_lasx_xvssub_s_d ++#define CODE_FOR_lasx_xvssub_bu CODE_FOR_lasx_xvssub_u_bu ++#define CODE_FOR_lasx_xvssub_hu CODE_FOR_lasx_xvssub_u_hu ++#define CODE_FOR_lasx_xvssub_wu CODE_FOR_lasx_xvssub_u_wu ++#define CODE_FOR_lasx_xvssub_du CODE_FOR_lasx_xvssub_u_du ++#define CODE_FOR_lasx_xvabsd_b CODE_FOR_lasx_xvabsd_s_b ++#define CODE_FOR_lasx_xvabsd_h CODE_FOR_lasx_xvabsd_s_h ++#define CODE_FOR_lasx_xvabsd_w CODE_FOR_lasx_xvabsd_s_w ++#define CODE_FOR_lasx_xvabsd_d CODE_FOR_lasx_xvabsd_s_d ++#define CODE_FOR_lasx_xvabsd_bu CODE_FOR_lasx_xvabsd_u_bu ++#define CODE_FOR_lasx_xvabsd_hu CODE_FOR_lasx_xvabsd_u_hu ++#define CODE_FOR_lasx_xvabsd_wu CODE_FOR_lasx_xvabsd_u_wu ++#define CODE_FOR_lasx_xvabsd_du CODE_FOR_lasx_xvabsd_u_du ++#define CODE_FOR_lasx_xvavg_b CODE_FOR_lasx_xvavg_s_b ++#define CODE_FOR_lasx_xvavg_h CODE_FOR_lasx_xvavg_s_h ++#define CODE_FOR_lasx_xvavg_w CODE_FOR_lasx_xvavg_s_w ++#define CODE_FOR_lasx_xvavg_d CODE_FOR_lasx_xvavg_s_d ++#define CODE_FOR_lasx_xvavg_bu CODE_FOR_lasx_xvavg_u_bu ++#define CODE_FOR_lasx_xvavg_hu CODE_FOR_lasx_xvavg_u_hu ++#define CODE_FOR_lasx_xvavg_wu CODE_FOR_lasx_xvavg_u_wu ++#define CODE_FOR_lasx_xvavg_du CODE_FOR_lasx_xvavg_u_du ++#define CODE_FOR_lasx_xvavgr_b CODE_FOR_lasx_xvavgr_s_b ++#define CODE_FOR_lasx_xvavgr_h CODE_FOR_lasx_xvavgr_s_h ++#define CODE_FOR_lasx_xvavgr_w CODE_FOR_lasx_xvavgr_s_w ++#define CODE_FOR_lasx_xvavgr_d CODE_FOR_lasx_xvavgr_s_d ++#define CODE_FOR_lasx_xvavgr_bu CODE_FOR_lasx_xvavgr_u_bu ++#define CODE_FOR_lasx_xvavgr_hu CODE_FOR_lasx_xvavgr_u_hu ++#define CODE_FOR_lasx_xvavgr_wu CODE_FOR_lasx_xvavgr_u_wu ++#define CODE_FOR_lasx_xvavgr_du CODE_FOR_lasx_xvavgr_u_du ++#define CODE_FOR_lasx_xvmuh_b CODE_FOR_lasx_xvmuh_s_b ++#define CODE_FOR_lasx_xvmuh_h CODE_FOR_lasx_xvmuh_s_h ++#define CODE_FOR_lasx_xvmuh_w CODE_FOR_lasx_xvmuh_s_w ++#define CODE_FOR_lasx_xvmuh_d CODE_FOR_lasx_xvmuh_s_d ++#define CODE_FOR_lasx_xvmuh_bu CODE_FOR_lasx_xvmuh_u_bu ++#define CODE_FOR_lasx_xvmuh_hu CODE_FOR_lasx_xvmuh_u_hu ++#define CODE_FOR_lasx_xvmuh_wu CODE_FOR_lasx_xvmuh_u_wu ++#define CODE_FOR_lasx_xvmuh_du CODE_FOR_lasx_xvmuh_u_du ++#define CODE_FOR_lasx_xvssran_b_h CODE_FOR_lasx_xvssran_s_b_h ++#define CODE_FOR_lasx_xvssran_h_w CODE_FOR_lasx_xvssran_s_h_w ++#define CODE_FOR_lasx_xvssran_w_d CODE_FOR_lasx_xvssran_s_w_d ++#define CODE_FOR_lasx_xvssran_bu_h CODE_FOR_lasx_xvssran_u_bu_h ++#define CODE_FOR_lasx_xvssran_hu_w CODE_FOR_lasx_xvssran_u_hu_w ++#define CODE_FOR_lasx_xvssran_wu_d CODE_FOR_lasx_xvssran_u_wu_d ++#define CODE_FOR_lasx_xvssrarn_b_h CODE_FOR_lasx_xvssrarn_s_b_h ++#define CODE_FOR_lasx_xvssrarn_h_w CODE_FOR_lasx_xvssrarn_s_h_w ++#define CODE_FOR_lasx_xvssrarn_w_d CODE_FOR_lasx_xvssrarn_s_w_d ++#define CODE_FOR_lasx_xvssrarn_bu_h CODE_FOR_lasx_xvssrarn_u_bu_h ++#define CODE_FOR_lasx_xvssrarn_hu_w CODE_FOR_lasx_xvssrarn_u_hu_w ++#define CODE_FOR_lasx_xvssrarn_wu_d CODE_FOR_lasx_xvssrarn_u_wu_d ++#define CODE_FOR_lasx_xvssrln_bu_h CODE_FOR_lasx_xvssrln_u_bu_h ++#define CODE_FOR_lasx_xvssrln_hu_w CODE_FOR_lasx_xvssrln_u_hu_w ++#define CODE_FOR_lasx_xvssrln_wu_d CODE_FOR_lasx_xvssrln_u_wu_d ++#define CODE_FOR_lasx_xvssrlrn_bu_h CODE_FOR_lasx_xvssrlrn_u_bu_h ++#define CODE_FOR_lasx_xvssrlrn_hu_w CODE_FOR_lasx_xvssrlrn_u_hu_w ++#define CODE_FOR_lasx_xvssrlrn_wu_d CODE_FOR_lasx_xvssrlrn_u_wu_d ++#define CODE_FOR_lasx_xvftint_w_s CODE_FOR_lasx_xvftint_s_w_s ++#define CODE_FOR_lasx_xvftint_l_d CODE_FOR_lasx_xvftint_s_l_d ++#define CODE_FOR_lasx_xvftint_wu_s CODE_FOR_lasx_xvftint_u_wu_s ++#define CODE_FOR_lasx_xvftint_lu_d CODE_FOR_lasx_xvftint_u_lu_d ++#define CODE_FOR_lasx_xvsllwil_h_b CODE_FOR_lasx_xvsllwil_s_h_b ++#define CODE_FOR_lasx_xvsllwil_w_h CODE_FOR_lasx_xvsllwil_s_w_h ++#define CODE_FOR_lasx_xvsllwil_d_w CODE_FOR_lasx_xvsllwil_s_d_w ++#define CODE_FOR_lasx_xvsllwil_hu_bu CODE_FOR_lasx_xvsllwil_u_hu_bu ++#define CODE_FOR_lasx_xvsllwil_wu_hu CODE_FOR_lasx_xvsllwil_u_wu_hu ++#define CODE_FOR_lasx_xvsllwil_du_wu CODE_FOR_lasx_xvsllwil_u_du_wu ++#define CODE_FOR_lasx_xvsat_b CODE_FOR_lasx_xvsat_s_b ++#define CODE_FOR_lasx_xvsat_h CODE_FOR_lasx_xvsat_s_h ++#define CODE_FOR_lasx_xvsat_w CODE_FOR_lasx_xvsat_s_w ++#define CODE_FOR_lasx_xvsat_d CODE_FOR_lasx_xvsat_s_d ++#define CODE_FOR_lasx_xvsat_bu CODE_FOR_lasx_xvsat_u_bu ++#define CODE_FOR_lasx_xvsat_hu CODE_FOR_lasx_xvsat_u_hu ++#define CODE_FOR_lasx_xvsat_wu CODE_FOR_lasx_xvsat_u_wu ++#define CODE_FOR_lasx_xvsat_du CODE_FOR_lasx_xvsat_u_du ++ + static const struct loongarch_builtin_description loongarch_builtins = { + #define LARCH_MOVFCSR2GR 0 + DIRECT_BUILTIN (movfcsr2gr, LARCH_USI_FTYPE_UQI, hard_float), +@@ -1209,7 +1511,761 @@ static const struct loongarch_builtin_description loongarch_builtins = { + LSX_BUILTIN (vshuf_b, LARCH_V16QI_FTYPE_V16QI_V16QI_V16QI), + LSX_BUILTIN (vldx, LARCH_V16QI_FTYPE_CVPOINTER_DI), + LSX_NO_TARGET_BUILTIN (vstx, LARCH_VOID_FTYPE_V16QI_CVPOINTER_DI), +- LSX_BUILTIN (vextl_qu_du, LARCH_UV2DI_FTYPE_UV2DI) ++ LSX_BUILTIN (vextl_qu_du, LARCH_UV2DI_FTYPE_UV2DI), ++ ++ /* Built-in functions for LASX */ ++ LASX_BUILTIN (xvsll_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsll_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsll_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsll_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvslli_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvslli_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvslli_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvslli_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvsra_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsra_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsra_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsra_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsrai_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvsrai_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvsrai_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvsrai_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvsrar_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsrar_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsrar_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsrar_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsrari_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvsrari_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvsrari_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvsrari_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvsrl_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsrl_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsrl_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsrl_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsrli_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvsrli_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvsrli_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvsrli_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvsrlr_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsrlr_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsrlr_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsrlr_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsrlri_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvsrlri_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvsrlri_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvsrlri_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvbitclr_b, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvbitclr_h, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvbitclr_w, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvbitclr_d, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvbitclri_b, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvbitclri_h, LARCH_UV16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvbitclri_w, LARCH_UV8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvbitclri_d, LARCH_UV4DI_FTYPE_UV4DI_UQI), ++ LASX_BUILTIN (xvbitset_b, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvbitset_h, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvbitset_w, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvbitset_d, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvbitseti_b, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvbitseti_h, LARCH_UV16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvbitseti_w, LARCH_UV8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvbitseti_d, LARCH_UV4DI_FTYPE_UV4DI_UQI), ++ LASX_BUILTIN (xvbitrev_b, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvbitrev_h, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvbitrev_w, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvbitrev_d, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvbitrevi_b, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvbitrevi_h, LARCH_UV16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvbitrevi_w, LARCH_UV8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvbitrevi_d, LARCH_UV4DI_FTYPE_UV4DI_UQI), ++ LASX_BUILTIN (xvadd_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvadd_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvadd_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvadd_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvaddi_bu, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvaddi_hu, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvaddi_wu, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvaddi_du, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvsub_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsub_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsub_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsub_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsubi_bu, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvsubi_hu, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvsubi_wu, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvsubi_du, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvmax_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvmax_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvmax_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvmax_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvmaxi_b, LARCH_V32QI_FTYPE_V32QI_QI), ++ LASX_BUILTIN (xvmaxi_h, LARCH_V16HI_FTYPE_V16HI_QI), ++ LASX_BUILTIN (xvmaxi_w, LARCH_V8SI_FTYPE_V8SI_QI), ++ LASX_BUILTIN (xvmaxi_d, LARCH_V4DI_FTYPE_V4DI_QI), ++ LASX_BUILTIN (xvmax_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmax_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmax_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmax_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvmaxi_bu, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvmaxi_hu, LARCH_UV16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvmaxi_wu, LARCH_UV8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvmaxi_du, LARCH_UV4DI_FTYPE_UV4DI_UQI), ++ LASX_BUILTIN (xvmin_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvmin_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvmin_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvmin_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvmini_b, LARCH_V32QI_FTYPE_V32QI_QI), ++ LASX_BUILTIN (xvmini_h, LARCH_V16HI_FTYPE_V16HI_QI), ++ LASX_BUILTIN (xvmini_w, LARCH_V8SI_FTYPE_V8SI_QI), ++ LASX_BUILTIN (xvmini_d, LARCH_V4DI_FTYPE_V4DI_QI), ++ LASX_BUILTIN (xvmin_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmin_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmin_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmin_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvmini_bu, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvmini_hu, LARCH_UV16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvmini_wu, LARCH_UV8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvmini_du, LARCH_UV4DI_FTYPE_UV4DI_UQI), ++ LASX_BUILTIN (xvseq_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvseq_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvseq_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvseq_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvseqi_b, LARCH_V32QI_FTYPE_V32QI_QI), ++ LASX_BUILTIN (xvseqi_h, LARCH_V16HI_FTYPE_V16HI_QI), ++ LASX_BUILTIN (xvseqi_w, LARCH_V8SI_FTYPE_V8SI_QI), ++ LASX_BUILTIN (xvseqi_d, LARCH_V4DI_FTYPE_V4DI_QI), ++ LASX_BUILTIN (xvslt_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvslt_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvslt_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvslt_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvslti_b, LARCH_V32QI_FTYPE_V32QI_QI), ++ LASX_BUILTIN (xvslti_h, LARCH_V16HI_FTYPE_V16HI_QI), ++ LASX_BUILTIN (xvslti_w, LARCH_V8SI_FTYPE_V8SI_QI), ++ LASX_BUILTIN (xvslti_d, LARCH_V4DI_FTYPE_V4DI_QI), ++ LASX_BUILTIN (xvslt_bu, LARCH_V32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvslt_hu, LARCH_V16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvslt_wu, LARCH_V8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvslt_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvslti_bu, LARCH_V32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvslti_hu, LARCH_V16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvslti_wu, LARCH_V8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvslti_du, LARCH_V4DI_FTYPE_UV4DI_UQI), ++ LASX_BUILTIN (xvsle_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsle_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsle_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsle_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvslei_b, LARCH_V32QI_FTYPE_V32QI_QI), ++ LASX_BUILTIN (xvslei_h, LARCH_V16HI_FTYPE_V16HI_QI), ++ LASX_BUILTIN (xvslei_w, LARCH_V8SI_FTYPE_V8SI_QI), ++ LASX_BUILTIN (xvslei_d, LARCH_V4DI_FTYPE_V4DI_QI), ++ LASX_BUILTIN (xvsle_bu, LARCH_V32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvsle_hu, LARCH_V16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvsle_wu, LARCH_V8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvsle_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvslei_bu, LARCH_V32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvslei_hu, LARCH_V16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvslei_wu, LARCH_V8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvslei_du, LARCH_V4DI_FTYPE_UV4DI_UQI), ++ ++ LASX_BUILTIN (xvsat_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvsat_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvsat_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvsat_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvsat_bu, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvsat_hu, LARCH_UV16HI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvsat_wu, LARCH_UV8SI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvsat_du, LARCH_UV4DI_FTYPE_UV4DI_UQI), ++ ++ LASX_BUILTIN (xvadda_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvadda_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvadda_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvadda_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsadd_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsadd_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsadd_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsadd_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsadd_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvsadd_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvsadd_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvsadd_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ ++ LASX_BUILTIN (xvavg_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvavg_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvavg_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvavg_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvavg_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvavg_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvavg_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvavg_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ ++ LASX_BUILTIN (xvavgr_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvavgr_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvavgr_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvavgr_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvavgr_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvavgr_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvavgr_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvavgr_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ ++ LASX_BUILTIN (xvssub_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvssub_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvssub_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvssub_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssub_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvssub_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvssub_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvssub_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvabsd_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvabsd_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvabsd_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvabsd_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvabsd_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvabsd_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvabsd_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvabsd_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ ++ LASX_BUILTIN (xvmul_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvmul_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvmul_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvmul_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvmadd_b, LARCH_V32QI_FTYPE_V32QI_V32QI_V32QI), ++ LASX_BUILTIN (xvmadd_h, LARCH_V16HI_FTYPE_V16HI_V16HI_V16HI), ++ LASX_BUILTIN (xvmadd_w, LARCH_V8SI_FTYPE_V8SI_V8SI_V8SI), ++ LASX_BUILTIN (xvmadd_d, LARCH_V4DI_FTYPE_V4DI_V4DI_V4DI), ++ LASX_BUILTIN (xvmsub_b, LARCH_V32QI_FTYPE_V32QI_V32QI_V32QI), ++ LASX_BUILTIN (xvmsub_h, LARCH_V16HI_FTYPE_V16HI_V16HI_V16HI), ++ LASX_BUILTIN (xvmsub_w, LARCH_V8SI_FTYPE_V8SI_V8SI_V8SI), ++ LASX_BUILTIN (xvmsub_d, LARCH_V4DI_FTYPE_V4DI_V4DI_V4DI), ++ LASX_BUILTIN (xvdiv_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvdiv_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvdiv_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvdiv_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvdiv_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvdiv_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvdiv_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvdiv_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvhaddw_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvhaddw_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvhaddw_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvhaddw_hu_bu, LARCH_UV16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvhaddw_wu_hu, LARCH_UV8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvhaddw_du_wu, LARCH_UV4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvhsubw_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvhsubw_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvhsubw_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvhsubw_hu_bu, LARCH_V16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvhsubw_wu_hu, LARCH_V8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvhsubw_du_wu, LARCH_V4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmod_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvmod_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvmod_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvmod_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvmod_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmod_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmod_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmod_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ ++ LASX_BUILTIN (xvrepl128vei_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvrepl128vei_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvrepl128vei_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvrepl128vei_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvpickev_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvpickev_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvpickev_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvpickev_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvpickod_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvpickod_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvpickod_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvpickod_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvilvh_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvilvh_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvilvh_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvilvh_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvilvl_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvilvl_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvilvl_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvilvl_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvpackev_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvpackev_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvpackev_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvpackev_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvpackod_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvpackod_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvpackod_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvpackod_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvshuf_b, LARCH_V32QI_FTYPE_V32QI_V32QI_V32QI), ++ LASX_BUILTIN (xvshuf_h, LARCH_V16HI_FTYPE_V16HI_V16HI_V16HI), ++ LASX_BUILTIN (xvshuf_w, LARCH_V8SI_FTYPE_V8SI_V8SI_V8SI), ++ LASX_BUILTIN (xvshuf_d, LARCH_V4DI_FTYPE_V4DI_V4DI_V4DI), ++ LASX_BUILTIN (xvand_v, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvandi_b, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvor_v, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvori_b, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvnor_v, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvnori_b, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvxor_v, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvxori_b, LARCH_UV32QI_FTYPE_UV32QI_UQI), ++ LASX_BUILTIN (xvbitsel_v, LARCH_UV32QI_FTYPE_UV32QI_UV32QI_UV32QI), ++ LASX_BUILTIN (xvbitseli_b, LARCH_UV32QI_FTYPE_UV32QI_UV32QI_USI), ++ ++ LASX_BUILTIN (xvshuf4i_b, LARCH_V32QI_FTYPE_V32QI_USI), ++ LASX_BUILTIN (xvshuf4i_h, LARCH_V16HI_FTYPE_V16HI_USI), ++ LASX_BUILTIN (xvshuf4i_w, LARCH_V8SI_FTYPE_V8SI_USI), ++ ++ LASX_BUILTIN (xvreplgr2vr_b, LARCH_V32QI_FTYPE_SI), ++ LASX_BUILTIN (xvreplgr2vr_h, LARCH_V16HI_FTYPE_SI), ++ LASX_BUILTIN (xvreplgr2vr_w, LARCH_V8SI_FTYPE_SI), ++ LASX_BUILTIN (xvreplgr2vr_d, LARCH_V4DI_FTYPE_DI), ++ LASX_BUILTIN (xvpcnt_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvpcnt_h, LARCH_V16HI_FTYPE_V16HI), ++ LASX_BUILTIN (xvpcnt_w, LARCH_V8SI_FTYPE_V8SI), ++ LASX_BUILTIN (xvpcnt_d, LARCH_V4DI_FTYPE_V4DI), ++ LASX_BUILTIN (xvclo_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvclo_h, LARCH_V16HI_FTYPE_V16HI), ++ LASX_BUILTIN (xvclo_w, LARCH_V8SI_FTYPE_V8SI), ++ LASX_BUILTIN (xvclo_d, LARCH_V4DI_FTYPE_V4DI), ++ LASX_BUILTIN (xvclz_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvclz_h, LARCH_V16HI_FTYPE_V16HI), ++ LASX_BUILTIN (xvclz_w, LARCH_V8SI_FTYPE_V8SI), ++ LASX_BUILTIN (xvclz_d, LARCH_V4DI_FTYPE_V4DI), ++ ++ LASX_BUILTIN (xvrepli_b, LARCH_V32QI_FTYPE_HI), ++ LASX_BUILTIN (xvrepli_h, LARCH_V16HI_FTYPE_HI), ++ LASX_BUILTIN (xvrepli_w, LARCH_V8SI_FTYPE_HI), ++ LASX_BUILTIN (xvrepli_d, LARCH_V4DI_FTYPE_HI), ++ LASX_BUILTIN (xvfcmp_caf_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_caf_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cor_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cor_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cun_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cun_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cune_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cune_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cueq_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cueq_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_ceq_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_ceq_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cne_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cne_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_clt_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_clt_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cult_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cult_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cle_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cle_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_cule_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_cule_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_saf_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_saf_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sor_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sor_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sun_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sun_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sune_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sune_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sueq_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sueq_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_seq_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_seq_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sne_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sne_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_slt_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_slt_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sult_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sult_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sle_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sle_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcmp_sule_s, LARCH_V8SI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcmp_sule_d, LARCH_V4DI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfadd_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfadd_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfsub_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfsub_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfmul_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfmul_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfdiv_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfdiv_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfcvt_h_s, LARCH_V16HI_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfcvt_s_d, LARCH_V8SF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfmin_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfmin_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfmina_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfmina_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfmax_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfmax_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfmaxa_s, LARCH_V8SF_FTYPE_V8SF_V8SF), ++ LASX_BUILTIN (xvfmaxa_d, LARCH_V4DF_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvfclass_s, LARCH_V8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvfclass_d, LARCH_V4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvfsqrt_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfsqrt_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvfrecip_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrecip_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvfrint_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrint_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvfrsqrt_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrsqrt_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvflogb_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvflogb_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvfcvth_s_h, LARCH_V8SF_FTYPE_V16HI), ++ LASX_BUILTIN (xvfcvth_d_s, LARCH_V4DF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfcvtl_s_h, LARCH_V8SF_FTYPE_V16HI), ++ LASX_BUILTIN (xvfcvtl_d_s, LARCH_V4DF_FTYPE_V8SF), ++ LASX_BUILTIN (xvftint_w_s, LARCH_V8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftint_l_d, LARCH_V4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvftint_wu_s, LARCH_UV8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftint_lu_d, LARCH_UV4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvftintrz_w_s, LARCH_V8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrz_l_d, LARCH_V4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvftintrz_wu_s, LARCH_UV8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrz_lu_d, LARCH_UV4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvffint_s_w, LARCH_V8SF_FTYPE_V8SI), ++ LASX_BUILTIN (xvffint_d_l, LARCH_V4DF_FTYPE_V4DI), ++ LASX_BUILTIN (xvffint_s_wu, LARCH_V8SF_FTYPE_UV8SI), ++ LASX_BUILTIN (xvffint_d_lu, LARCH_V4DF_FTYPE_UV4DI), ++ ++ LASX_BUILTIN (xvreplve_b, LARCH_V32QI_FTYPE_V32QI_SI), ++ LASX_BUILTIN (xvreplve_h, LARCH_V16HI_FTYPE_V16HI_SI), ++ LASX_BUILTIN (xvreplve_w, LARCH_V8SI_FTYPE_V8SI_SI), ++ LASX_BUILTIN (xvreplve_d, LARCH_V4DI_FTYPE_V4DI_SI), ++ LASX_BUILTIN (xvpermi_w, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ ++ LASX_BUILTIN (xvandn_v, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvneg_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvneg_h, LARCH_V16HI_FTYPE_V16HI), ++ LASX_BUILTIN (xvneg_w, LARCH_V8SI_FTYPE_V8SI), ++ LASX_BUILTIN (xvneg_d, LARCH_V4DI_FTYPE_V4DI), ++ LASX_BUILTIN (xvmuh_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvmuh_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvmuh_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvmuh_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvmuh_bu, LARCH_UV32QI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmuh_hu, LARCH_UV16HI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmuh_wu, LARCH_UV8SI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmuh_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvsllwil_h_b, LARCH_V16HI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvsllwil_w_h, LARCH_V8SI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvsllwil_d_w, LARCH_V4DI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvsllwil_hu_bu, LARCH_UV16HI_FTYPE_UV32QI_UQI), /* FIXME: U? */ ++ LASX_BUILTIN (xvsllwil_wu_hu, LARCH_UV8SI_FTYPE_UV16HI_UQI), ++ LASX_BUILTIN (xvsllwil_du_wu, LARCH_UV4DI_FTYPE_UV8SI_UQI), ++ LASX_BUILTIN (xvsran_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsran_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsran_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssran_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvssran_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvssran_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssran_bu_h, LARCH_UV32QI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvssran_hu_w, LARCH_UV16HI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvssran_wu_d, LARCH_UV8SI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvsrarn_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsrarn_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsrarn_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssrarn_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvssrarn_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvssrarn_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssrarn_bu_h, LARCH_UV32QI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvssrarn_hu_w, LARCH_UV16HI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvssrarn_wu_d, LARCH_UV8SI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvsrln_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsrln_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsrln_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssrln_bu_h, LARCH_UV32QI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvssrln_hu_w, LARCH_UV16HI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvssrln_wu_d, LARCH_UV8SI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvsrlrn_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsrlrn_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsrlrn_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssrlrn_bu_h, LARCH_UV32QI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvssrlrn_hu_w, LARCH_UV16HI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvssrlrn_wu_d, LARCH_UV8SI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvfrstpi_b, LARCH_V32QI_FTYPE_V32QI_V32QI_UQI), ++ LASX_BUILTIN (xvfrstpi_h, LARCH_V16HI_FTYPE_V16HI_V16HI_UQI), ++ LASX_BUILTIN (xvfrstp_b, LARCH_V32QI_FTYPE_V32QI_V32QI_V32QI), ++ LASX_BUILTIN (xvfrstp_h, LARCH_V16HI_FTYPE_V16HI_V16HI_V16HI), ++ LASX_BUILTIN (xvshuf4i_d, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvbsrl_v, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvbsll_v, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvextrins_b, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvextrins_h, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvextrins_w, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvextrins_d, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvmskltz_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvmskltz_h, LARCH_V16HI_FTYPE_V16HI), ++ LASX_BUILTIN (xvmskltz_w, LARCH_V8SI_FTYPE_V8SI), ++ LASX_BUILTIN (xvmskltz_d, LARCH_V4DI_FTYPE_V4DI), ++ LASX_BUILTIN (xvsigncov_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsigncov_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsigncov_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsigncov_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvfmadd_s, LARCH_V8SF_FTYPE_V8SF_V8SF_V8SF), ++ LASX_BUILTIN (xvfmadd_d, LARCH_V4DF_FTYPE_V4DF_V4DF_V4DF), ++ LASX_BUILTIN (xvfmsub_s, LARCH_V8SF_FTYPE_V8SF_V8SF_V8SF), ++ LASX_BUILTIN (xvfmsub_d, LARCH_V4DF_FTYPE_V4DF_V4DF_V4DF), ++ LASX_BUILTIN (xvfnmadd_s, LARCH_V8SF_FTYPE_V8SF_V8SF_V8SF), ++ LASX_BUILTIN (xvfnmadd_d, LARCH_V4DF_FTYPE_V4DF_V4DF_V4DF), ++ LASX_BUILTIN (xvfnmsub_s, LARCH_V8SF_FTYPE_V8SF_V8SF_V8SF), ++ LASX_BUILTIN (xvfnmsub_d, LARCH_V4DF_FTYPE_V4DF_V4DF_V4DF), ++ LASX_BUILTIN (xvftintrne_w_s, LARCH_V8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrne_l_d, LARCH_V4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvftintrp_w_s, LARCH_V8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrp_l_d, LARCH_V4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvftintrm_w_s, LARCH_V8SI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrm_l_d, LARCH_V4DI_FTYPE_V4DF), ++ LASX_BUILTIN (xvftint_w_d, LARCH_V8SI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvffint_s_l, LARCH_V8SF_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvftintrz_w_d, LARCH_V8SI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvftintrp_w_d, LARCH_V8SI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvftintrm_w_d, LARCH_V8SI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvftintrne_w_d, LARCH_V8SI_FTYPE_V4DF_V4DF), ++ LASX_BUILTIN (xvftinth_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintl_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvffinth_d_w, LARCH_V4DF_FTYPE_V8SI), ++ LASX_BUILTIN (xvffintl_d_w, LARCH_V4DF_FTYPE_V8SI), ++ LASX_BUILTIN (xvftintrzh_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrzl_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrph_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrpl_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrmh_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrml_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrneh_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvftintrnel_l_s, LARCH_V4DI_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrintrne_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrintrne_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvfrintrz_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrintrz_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvfrintrp_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrintrp_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvfrintrm_s, LARCH_V8SF_FTYPE_V8SF), ++ LASX_BUILTIN (xvfrintrm_d, LARCH_V4DF_FTYPE_V4DF), ++ LASX_BUILTIN (xvld, LARCH_V32QI_FTYPE_CVPOINTER_SI), ++ LASX_NO_TARGET_BUILTIN (xvst, LARCH_VOID_FTYPE_V32QI_CVPOINTER_SI), ++ LASX_NO_TARGET_BUILTIN (xvstelm_b, LARCH_VOID_FTYPE_V32QI_CVPOINTER_SI_UQI), ++ LASX_NO_TARGET_BUILTIN (xvstelm_h, LARCH_VOID_FTYPE_V16HI_CVPOINTER_SI_UQI), ++ LASX_NO_TARGET_BUILTIN (xvstelm_w, LARCH_VOID_FTYPE_V8SI_CVPOINTER_SI_UQI), ++ LASX_NO_TARGET_BUILTIN (xvstelm_d, LARCH_VOID_FTYPE_V4DI_CVPOINTER_SI_UQI), ++ LASX_BUILTIN (xvinsve0_w, LARCH_V8SI_FTYPE_V8SI_V8SI_UQI), ++ LASX_BUILTIN (xvinsve0_d, LARCH_V4DI_FTYPE_V4DI_V4DI_UQI), ++ LASX_BUILTIN (xvpickve_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvpickve_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvpickve_w_f, LARCH_V8SF_FTYPE_V8SF_UQI), ++ LASX_BUILTIN (xvpickve_d_f, LARCH_V4DF_FTYPE_V4DF_UQI), ++ LASX_BUILTIN (xvssrlrn_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvssrlrn_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvssrlrn_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvssrln_b_h, LARCH_V32QI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvssrln_h_w, LARCH_V16HI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvssrln_w_d, LARCH_V8SI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvorn_v, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvldi, LARCH_V4DI_FTYPE_HI), ++ LASX_BUILTIN (xvldx, LARCH_V32QI_FTYPE_CVPOINTER_DI), ++ LASX_NO_TARGET_BUILTIN (xvstx, LARCH_VOID_FTYPE_V32QI_CVPOINTER_DI), ++ LASX_BUILTIN (xvextl_qu_du, LARCH_UV4DI_FTYPE_UV4DI), ++ ++ /* LASX */ ++ LASX_BUILTIN (xvinsgr2vr_w, LARCH_V8SI_FTYPE_V8SI_SI_UQI), ++ LASX_BUILTIN (xvinsgr2vr_d, LARCH_V4DI_FTYPE_V4DI_DI_UQI), ++ ++ LASX_BUILTIN (xvreplve0_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvreplve0_h, LARCH_V16HI_FTYPE_V16HI), ++ LASX_BUILTIN (xvreplve0_w, LARCH_V8SI_FTYPE_V8SI), ++ LASX_BUILTIN (xvreplve0_d, LARCH_V4DI_FTYPE_V4DI), ++ LASX_BUILTIN (xvreplve0_q, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (vext2xv_h_b, LARCH_V16HI_FTYPE_V32QI), ++ LASX_BUILTIN (vext2xv_w_h, LARCH_V8SI_FTYPE_V16HI), ++ LASX_BUILTIN (vext2xv_d_w, LARCH_V4DI_FTYPE_V8SI), ++ LASX_BUILTIN (vext2xv_w_b, LARCH_V8SI_FTYPE_V32QI), ++ LASX_BUILTIN (vext2xv_d_h, LARCH_V4DI_FTYPE_V16HI), ++ LASX_BUILTIN (vext2xv_d_b, LARCH_V4DI_FTYPE_V32QI), ++ LASX_BUILTIN (vext2xv_hu_bu, LARCH_V16HI_FTYPE_V32QI), ++ LASX_BUILTIN (vext2xv_wu_hu, LARCH_V8SI_FTYPE_V16HI), ++ LASX_BUILTIN (vext2xv_du_wu, LARCH_V4DI_FTYPE_V8SI), ++ LASX_BUILTIN (vext2xv_wu_bu, LARCH_V8SI_FTYPE_V32QI), ++ LASX_BUILTIN (vext2xv_du_hu, LARCH_V4DI_FTYPE_V16HI), ++ LASX_BUILTIN (vext2xv_du_bu, LARCH_V4DI_FTYPE_V32QI), ++ LASX_BUILTIN (xvpermi_q, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvpermi_d, LARCH_V4DI_FTYPE_V4DI_USI), ++ LASX_BUILTIN (xvperm_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN_TEST_BRANCH (xbz_b, LARCH_SI_FTYPE_UV32QI), ++ LASX_BUILTIN_TEST_BRANCH (xbz_h, LARCH_SI_FTYPE_UV16HI), ++ LASX_BUILTIN_TEST_BRANCH (xbz_w, LARCH_SI_FTYPE_UV8SI), ++ LASX_BUILTIN_TEST_BRANCH (xbz_d, LARCH_SI_FTYPE_UV4DI), ++ LASX_BUILTIN_TEST_BRANCH (xbnz_b, LARCH_SI_FTYPE_UV32QI), ++ LASX_BUILTIN_TEST_BRANCH (xbnz_h, LARCH_SI_FTYPE_UV16HI), ++ LASX_BUILTIN_TEST_BRANCH (xbnz_w, LARCH_SI_FTYPE_UV8SI), ++ LASX_BUILTIN_TEST_BRANCH (xbnz_d, LARCH_SI_FTYPE_UV4DI), ++ LASX_BUILTIN_TEST_BRANCH (xbz_v, LARCH_SI_FTYPE_UV32QI), ++ LASX_BUILTIN_TEST_BRANCH (xbnz_v, LARCH_SI_FTYPE_UV32QI), ++ LASX_BUILTIN (xvldrepl_b, LARCH_V32QI_FTYPE_CVPOINTER_SI), ++ LASX_BUILTIN (xvldrepl_h, LARCH_V16HI_FTYPE_CVPOINTER_SI), ++ LASX_BUILTIN (xvldrepl_w, LARCH_V8SI_FTYPE_CVPOINTER_SI), ++ LASX_BUILTIN (xvldrepl_d, LARCH_V4DI_FTYPE_CVPOINTER_SI), ++ LASX_BUILTIN (xvpickve2gr_w, LARCH_SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvpickve2gr_wu, LARCH_USI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvpickve2gr_d, LARCH_DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvpickve2gr_du, LARCH_UDI_FTYPE_V4DI_UQI), ++ ++ LASX_BUILTIN (xvaddwev_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvaddwev_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvaddwev_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvaddwev_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvaddwev_q_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvaddwev_d_wu, LARCH_V4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvaddwev_w_hu, LARCH_V8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvaddwev_h_bu, LARCH_V16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvsubwev_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsubwev_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsubwev_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsubwev_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsubwev_q_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvsubwev_d_wu, LARCH_V4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvsubwev_w_hu, LARCH_V8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvsubwev_h_bu, LARCH_V16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmulwev_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvmulwev_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvmulwev_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvmulwev_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvmulwev_q_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvmulwev_d_wu, LARCH_V4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmulwev_w_hu, LARCH_V8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmulwev_h_bu, LARCH_V16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvaddwod_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvaddwod_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvaddwod_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvaddwod_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvaddwod_q_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvaddwod_d_wu, LARCH_V4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvaddwod_w_hu, LARCH_V8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvaddwod_h_bu, LARCH_V16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvsubwod_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsubwod_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvsubwod_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvsubwod_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvsubwod_q_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvsubwod_d_wu, LARCH_V4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvsubwod_w_hu, LARCH_V8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvsubwod_h_bu, LARCH_V16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmulwod_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvmulwod_d_w, LARCH_V4DI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvmulwod_w_h, LARCH_V8SI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvmulwod_h_b, LARCH_V16HI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvmulwod_q_du, LARCH_V4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvmulwod_d_wu, LARCH_V4DI_FTYPE_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmulwod_w_hu, LARCH_V8SI_FTYPE_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmulwod_h_bu, LARCH_V16HI_FTYPE_UV32QI_UV32QI), ++ LASX_BUILTIN (xvaddwev_d_wu_w, LARCH_V4DI_FTYPE_UV8SI_V8SI), ++ LASX_BUILTIN (xvaddwev_w_hu_h, LARCH_V8SI_FTYPE_UV16HI_V16HI), ++ LASX_BUILTIN (xvaddwev_h_bu_b, LARCH_V16HI_FTYPE_UV32QI_V32QI), ++ LASX_BUILTIN (xvmulwev_d_wu_w, LARCH_V4DI_FTYPE_UV8SI_V8SI), ++ LASX_BUILTIN (xvmulwev_w_hu_h, LARCH_V8SI_FTYPE_UV16HI_V16HI), ++ LASX_BUILTIN (xvmulwev_h_bu_b, LARCH_V16HI_FTYPE_UV32QI_V32QI), ++ LASX_BUILTIN (xvaddwod_d_wu_w, LARCH_V4DI_FTYPE_UV8SI_V8SI), ++ LASX_BUILTIN (xvaddwod_w_hu_h, LARCH_V8SI_FTYPE_UV16HI_V16HI), ++ LASX_BUILTIN (xvaddwod_h_bu_b, LARCH_V16HI_FTYPE_UV32QI_V32QI), ++ LASX_BUILTIN (xvmulwod_d_wu_w, LARCH_V4DI_FTYPE_UV8SI_V8SI), ++ LASX_BUILTIN (xvmulwod_w_hu_h, LARCH_V8SI_FTYPE_UV16HI_V16HI), ++ LASX_BUILTIN (xvmulwod_h_bu_b, LARCH_V16HI_FTYPE_UV32QI_V32QI), ++ LASX_BUILTIN (xvhaddw_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvhaddw_qu_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvhsubw_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvhsubw_qu_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI), ++ LASX_BUILTIN (xvmaddwev_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI_V4DI), ++ LASX_BUILTIN (xvmaddwev_d_w, LARCH_V4DI_FTYPE_V4DI_V8SI_V8SI), ++ LASX_BUILTIN (xvmaddwev_w_h, LARCH_V8SI_FTYPE_V8SI_V16HI_V16HI), ++ LASX_BUILTIN (xvmaddwev_h_b, LARCH_V16HI_FTYPE_V16HI_V32QI_V32QI), ++ LASX_BUILTIN (xvmaddwev_q_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI_UV4DI), ++ LASX_BUILTIN (xvmaddwev_d_wu, LARCH_UV4DI_FTYPE_UV4DI_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmaddwev_w_hu, LARCH_UV8SI_FTYPE_UV8SI_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmaddwev_h_bu, LARCH_UV16HI_FTYPE_UV16HI_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmaddwod_q_d, LARCH_V4DI_FTYPE_V4DI_V4DI_V4DI), ++ LASX_BUILTIN (xvmaddwod_d_w, LARCH_V4DI_FTYPE_V4DI_V8SI_V8SI), ++ LASX_BUILTIN (xvmaddwod_w_h, LARCH_V8SI_FTYPE_V8SI_V16HI_V16HI), ++ LASX_BUILTIN (xvmaddwod_h_b, LARCH_V16HI_FTYPE_V16HI_V32QI_V32QI), ++ LASX_BUILTIN (xvmaddwod_q_du, LARCH_UV4DI_FTYPE_UV4DI_UV4DI_UV4DI), ++ LASX_BUILTIN (xvmaddwod_d_wu, LARCH_UV4DI_FTYPE_UV4DI_UV8SI_UV8SI), ++ LASX_BUILTIN (xvmaddwod_w_hu, LARCH_UV8SI_FTYPE_UV8SI_UV16HI_UV16HI), ++ LASX_BUILTIN (xvmaddwod_h_bu, LARCH_UV16HI_FTYPE_UV16HI_UV32QI_UV32QI), ++ LASX_BUILTIN (xvmaddwev_q_du_d, LARCH_V4DI_FTYPE_V4DI_UV4DI_V4DI), ++ LASX_BUILTIN (xvmaddwev_d_wu_w, LARCH_V4DI_FTYPE_V4DI_UV8SI_V8SI), ++ LASX_BUILTIN (xvmaddwev_w_hu_h, LARCH_V8SI_FTYPE_V8SI_UV16HI_V16HI), ++ LASX_BUILTIN (xvmaddwev_h_bu_b, LARCH_V16HI_FTYPE_V16HI_UV32QI_V32QI), ++ LASX_BUILTIN (xvmaddwod_q_du_d, LARCH_V4DI_FTYPE_V4DI_UV4DI_V4DI), ++ LASX_BUILTIN (xvmaddwod_d_wu_w, LARCH_V4DI_FTYPE_V4DI_UV8SI_V8SI), ++ LASX_BUILTIN (xvmaddwod_w_hu_h, LARCH_V8SI_FTYPE_V8SI_UV16HI_V16HI), ++ LASX_BUILTIN (xvmaddwod_h_bu_b, LARCH_V16HI_FTYPE_V16HI_UV32QI_V32QI), ++ LASX_BUILTIN (xvrotr_b, LARCH_V32QI_FTYPE_V32QI_V32QI), ++ LASX_BUILTIN (xvrotr_h, LARCH_V16HI_FTYPE_V16HI_V16HI), ++ LASX_BUILTIN (xvrotr_w, LARCH_V8SI_FTYPE_V8SI_V8SI), ++ LASX_BUILTIN (xvrotr_d, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvadd_q, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvsub_q, LARCH_V4DI_FTYPE_V4DI_V4DI), ++ LASX_BUILTIN (xvaddwev_q_du_d, LARCH_V4DI_FTYPE_UV4DI_V4DI), ++ LASX_BUILTIN (xvaddwod_q_du_d, LARCH_V4DI_FTYPE_UV4DI_V4DI), ++ LASX_BUILTIN (xvmulwev_q_du_d, LARCH_V4DI_FTYPE_UV4DI_V4DI), ++ LASX_BUILTIN (xvmulwod_q_du_d, LARCH_V4DI_FTYPE_UV4DI_V4DI), ++ LASX_BUILTIN (xvmskgez_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvmsknz_b, LARCH_V32QI_FTYPE_V32QI), ++ LASX_BUILTIN (xvexth_h_b, LARCH_V16HI_FTYPE_V32QI), ++ LASX_BUILTIN (xvexth_w_h, LARCH_V8SI_FTYPE_V16HI), ++ LASX_BUILTIN (xvexth_d_w, LARCH_V4DI_FTYPE_V8SI), ++ LASX_BUILTIN (xvexth_q_d, LARCH_V4DI_FTYPE_V4DI), ++ LASX_BUILTIN (xvexth_hu_bu, LARCH_UV16HI_FTYPE_UV32QI), ++ LASX_BUILTIN (xvexth_wu_hu, LARCH_UV8SI_FTYPE_UV16HI), ++ LASX_BUILTIN (xvexth_du_wu, LARCH_UV4DI_FTYPE_UV8SI), ++ LASX_BUILTIN (xvexth_qu_du, LARCH_UV4DI_FTYPE_UV4DI), ++ LASX_BUILTIN (xvrotri_b, LARCH_V32QI_FTYPE_V32QI_UQI), ++ LASX_BUILTIN (xvrotri_h, LARCH_V16HI_FTYPE_V16HI_UQI), ++ LASX_BUILTIN (xvrotri_w, LARCH_V8SI_FTYPE_V8SI_UQI), ++ LASX_BUILTIN (xvrotri_d, LARCH_V4DI_FTYPE_V4DI_UQI), ++ LASX_BUILTIN (xvextl_q_d, LARCH_V4DI_FTYPE_V4DI), ++ LASX_BUILTIN (xvsrlni_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvsrlni_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvsrlni_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvsrlni_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvsrlrni_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvsrlrni_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvsrlrni_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvsrlrni_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrlni_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrlni_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrlni_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrlni_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrlni_bu_h, LARCH_UV32QI_FTYPE_UV32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrlni_hu_w, LARCH_UV16HI_FTYPE_UV16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrlni_wu_d, LARCH_UV8SI_FTYPE_UV8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrlni_du_q, LARCH_UV4DI_FTYPE_UV4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrlrni_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrlrni_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrlrni_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrlrni_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrlrni_bu_h, LARCH_UV32QI_FTYPE_UV32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrlrni_hu_w, LARCH_UV16HI_FTYPE_UV16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrlrni_wu_d, LARCH_UV8SI_FTYPE_UV8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrlrni_du_q, LARCH_UV4DI_FTYPE_UV4DI_V4DI_USI), ++ LASX_BUILTIN (xvsrani_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvsrani_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvsrani_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvsrani_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvsrarni_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvsrarni_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvsrarni_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvsrarni_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrani_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrani_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrani_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrani_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrani_bu_h, LARCH_UV32QI_FTYPE_UV32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrani_hu_w, LARCH_UV16HI_FTYPE_UV16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrani_wu_d, LARCH_UV8SI_FTYPE_UV8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrani_du_q, LARCH_UV4DI_FTYPE_UV4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrarni_b_h, LARCH_V32QI_FTYPE_V32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrarni_h_w, LARCH_V16HI_FTYPE_V16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrarni_w_d, LARCH_V8SI_FTYPE_V8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrarni_d_q, LARCH_V4DI_FTYPE_V4DI_V4DI_USI), ++ LASX_BUILTIN (xvssrarni_bu_h, LARCH_UV32QI_FTYPE_UV32QI_V32QI_USI), ++ LASX_BUILTIN (xvssrarni_hu_w, LARCH_UV16HI_FTYPE_UV16HI_V16HI_USI), ++ LASX_BUILTIN (xvssrarni_wu_d, LARCH_UV8SI_FTYPE_UV8SI_V8SI_USI), ++ LASX_BUILTIN (xvssrarni_du_q, LARCH_UV4DI_FTYPE_UV4DI_V4DI_USI) + }; + + /* Index I is the function declaration for loongarch_builtinsI, or null if +@@ -1446,11 +2502,15 @@ loongarch_builtin_vectorized_function (unsigned int fn, tree type_out, + { + if (out_n == 2 && in_n == 2) + return LARCH_GET_BUILTIN (lsx_vfrintrp_d); ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lasx_xvfrintrp_d); + } + if (out_mode == SFmode && in_mode == SFmode) + { + if (out_n == 4 && in_n == 4) + return LARCH_GET_BUILTIN (lsx_vfrintrp_s); ++ if (out_n == 8 && in_n == 8) ++ return LARCH_GET_BUILTIN (lasx_xvfrintrp_s); + } + break; + +@@ -1459,11 +2519,15 @@ loongarch_builtin_vectorized_function (unsigned int fn, tree type_out, + { + if (out_n == 2 && in_n == 2) + return LARCH_GET_BUILTIN (lsx_vfrintrz_d); ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lasx_xvfrintrz_d); + } + if (out_mode == SFmode && in_mode == SFmode) + { + if (out_n == 4 && in_n == 4) + return LARCH_GET_BUILTIN (lsx_vfrintrz_s); ++ if (out_n == 8 && in_n == 8) ++ return LARCH_GET_BUILTIN (lasx_xvfrintrz_s); + } + break; + +@@ -1473,11 +2537,15 @@ loongarch_builtin_vectorized_function (unsigned int fn, tree type_out, + { + if (out_n == 2 && in_n == 2) + return LARCH_GET_BUILTIN (lsx_vfrint_d); ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lasx_xvfrint_d); + } + if (out_mode == SFmode && in_mode == SFmode) + { + if (out_n == 4 && in_n == 4) + return LARCH_GET_BUILTIN (lsx_vfrint_s); ++ if (out_n == 8 && in_n == 8) ++ return LARCH_GET_BUILTIN (lasx_xvfrint_s); + } + break; + +@@ -1486,11 +2554,15 @@ loongarch_builtin_vectorized_function (unsigned int fn, tree type_out, + { + if (out_n == 2 && in_n == 2) + return LARCH_GET_BUILTIN (lsx_vfrintrm_d); ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lasx_xvfrintrm_d); + } + if (out_mode == SFmode && in_mode == SFmode) + { + if (out_n == 4 && in_n == 4) + return LARCH_GET_BUILTIN (lsx_vfrintrm_s); ++ if (out_n == 8 && in_n == 8) ++ return LARCH_GET_BUILTIN (lasx_xvfrintrm_s); + } + break; + +@@ -1565,6 +2637,30 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + case CODE_FOR_lsx_vsubi_hu: + case CODE_FOR_lsx_vsubi_wu: + case CODE_FOR_lsx_vsubi_du: ++ case CODE_FOR_lasx_xvaddi_bu: ++ case CODE_FOR_lasx_xvaddi_hu: ++ case CODE_FOR_lasx_xvaddi_wu: ++ case CODE_FOR_lasx_xvaddi_du: ++ case CODE_FOR_lasx_xvslti_bu: ++ case CODE_FOR_lasx_xvslti_hu: ++ case CODE_FOR_lasx_xvslti_wu: ++ case CODE_FOR_lasx_xvslti_du: ++ case CODE_FOR_lasx_xvslei_bu: ++ case CODE_FOR_lasx_xvslei_hu: ++ case CODE_FOR_lasx_xvslei_wu: ++ case CODE_FOR_lasx_xvslei_du: ++ case CODE_FOR_lasx_xvmaxi_bu: ++ case CODE_FOR_lasx_xvmaxi_hu: ++ case CODE_FOR_lasx_xvmaxi_wu: ++ case CODE_FOR_lasx_xvmaxi_du: ++ case CODE_FOR_lasx_xvmini_bu: ++ case CODE_FOR_lasx_xvmini_hu: ++ case CODE_FOR_lasx_xvmini_wu: ++ case CODE_FOR_lasx_xvmini_du: ++ case CODE_FOR_lasx_xvsubi_bu: ++ case CODE_FOR_lasx_xvsubi_hu: ++ case CODE_FOR_lasx_xvsubi_wu: ++ case CODE_FOR_lasx_xvsubi_du: + gcc_assert (has_target_p && nops == 3); + /* We only generate a vector of constants iff the second argument + is an immediate. We also validate the range of the immediate. */ +@@ -1603,6 +2699,26 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + case CODE_FOR_lsx_vmini_h: + case CODE_FOR_lsx_vmini_w: + case CODE_FOR_lsx_vmini_d: ++ case CODE_FOR_lasx_xvseqi_b: ++ case CODE_FOR_lasx_xvseqi_h: ++ case CODE_FOR_lasx_xvseqi_w: ++ case CODE_FOR_lasx_xvseqi_d: ++ case CODE_FOR_lasx_xvslti_b: ++ case CODE_FOR_lasx_xvslti_h: ++ case CODE_FOR_lasx_xvslti_w: ++ case CODE_FOR_lasx_xvslti_d: ++ case CODE_FOR_lasx_xvslei_b: ++ case CODE_FOR_lasx_xvslei_h: ++ case CODE_FOR_lasx_xvslei_w: ++ case CODE_FOR_lasx_xvslei_d: ++ case CODE_FOR_lasx_xvmaxi_b: ++ case CODE_FOR_lasx_xvmaxi_h: ++ case CODE_FOR_lasx_xvmaxi_w: ++ case CODE_FOR_lasx_xvmaxi_d: ++ case CODE_FOR_lasx_xvmini_b: ++ case CODE_FOR_lasx_xvmini_h: ++ case CODE_FOR_lasx_xvmini_w: ++ case CODE_FOR_lasx_xvmini_d: + gcc_assert (has_target_p && nops == 3); + /* We only generate a vector of constants iff the second argument + is an immediate. We also validate the range of the immediate. */ +@@ -1625,6 +2741,10 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + case CODE_FOR_lsx_vori_b: + case CODE_FOR_lsx_vnori_b: + case CODE_FOR_lsx_vxori_b: ++ case CODE_FOR_lasx_xvandi_b: ++ case CODE_FOR_lasx_xvori_b: ++ case CODE_FOR_lasx_xvnori_b: ++ case CODE_FOR_lasx_xvxori_b: + gcc_assert (has_target_p && nops == 3); + if (!CONST_INT_P (ops2.value)) + break; +@@ -1634,6 +2754,7 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + break; + + case CODE_FOR_lsx_vbitseli_b: ++ case CODE_FOR_lasx_xvbitseli_b: + gcc_assert (has_target_p && nops == 4); + if (!CONST_INT_P (ops3.value)) + break; +@@ -1646,6 +2767,10 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + case CODE_FOR_lsx_vreplgr2vr_h: + case CODE_FOR_lsx_vreplgr2vr_w: + case CODE_FOR_lsx_vreplgr2vr_d: ++ case CODE_FOR_lasx_xvreplgr2vr_b: ++ case CODE_FOR_lasx_xvreplgr2vr_h: ++ case CODE_FOR_lasx_xvreplgr2vr_w: ++ case CODE_FOR_lasx_xvreplgr2vr_d: + /* Map the built-ins to vector fill operations. We need fix up the mode + for the element being inserted. */ + gcc_assert (has_target_p && nops == 2); +@@ -1674,6 +2799,26 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + case CODE_FOR_lsx_vpickod_b: + case CODE_FOR_lsx_vpickod_h: + case CODE_FOR_lsx_vpickod_w: ++ case CODE_FOR_lasx_xvilvh_b: ++ case CODE_FOR_lasx_xvilvh_h: ++ case CODE_FOR_lasx_xvilvh_w: ++ case CODE_FOR_lasx_xvilvh_d: ++ case CODE_FOR_lasx_xvilvl_b: ++ case CODE_FOR_lasx_xvilvl_h: ++ case CODE_FOR_lasx_xvilvl_w: ++ case CODE_FOR_lasx_xvilvl_d: ++ case CODE_FOR_lasx_xvpackev_b: ++ case CODE_FOR_lasx_xvpackev_h: ++ case CODE_FOR_lasx_xvpackev_w: ++ case CODE_FOR_lasx_xvpackod_b: ++ case CODE_FOR_lasx_xvpackod_h: ++ case CODE_FOR_lasx_xvpackod_w: ++ case CODE_FOR_lasx_xvpickev_b: ++ case CODE_FOR_lasx_xvpickev_h: ++ case CODE_FOR_lasx_xvpickev_w: ++ case CODE_FOR_lasx_xvpickod_b: ++ case CODE_FOR_lasx_xvpickod_h: ++ case CODE_FOR_lasx_xvpickod_w: + /* Swap the operands 1 and 2 for interleave operations. Built-ins follow + convention of ISA, which have op1 as higher component and op2 as lower + component. However, the VEC_PERM op in tree and vec_concat in RTL +@@ -1695,6 +2840,18 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + case CODE_FOR_lsx_vsrli_h: + case CODE_FOR_lsx_vsrli_w: + case CODE_FOR_lsx_vsrli_d: ++ case CODE_FOR_lasx_xvslli_b: ++ case CODE_FOR_lasx_xvslli_h: ++ case CODE_FOR_lasx_xvslli_w: ++ case CODE_FOR_lasx_xvslli_d: ++ case CODE_FOR_lasx_xvsrai_b: ++ case CODE_FOR_lasx_xvsrai_h: ++ case CODE_FOR_lasx_xvsrai_w: ++ case CODE_FOR_lasx_xvsrai_d: ++ case CODE_FOR_lasx_xvsrli_b: ++ case CODE_FOR_lasx_xvsrli_h: ++ case CODE_FOR_lasx_xvsrli_w: ++ case CODE_FOR_lasx_xvsrli_d: + gcc_assert (has_target_p && nops == 3); + if (CONST_INT_P (ops2.value)) + { +@@ -1755,6 +2912,25 @@ loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + INTVAL (ops2.value)); + break; + ++ case CODE_FOR_lasx_xvinsgr2vr_w: ++ case CODE_FOR_lasx_xvinsgr2vr_d: ++ /* Map the built-ins to insert operations. We need to swap operands, ++ fix up the mode for the element being inserted, and generate ++ a bit mask for vec_merge. */ ++ gcc_assert (has_target_p && nops == 4); ++ std::swap (ops1, ops2); ++ imode = GET_MODE_INNER (ops0.mode); ++ ops1.value = lowpart_subreg (imode, ops1.value, ops1.mode); ++ ops1.mode = imode; ++ rangelo = 0; ++ rangehi = GET_MODE_NUNITS (ops0.mode) - 1; ++ if (CONST_INT_P (ops3.value) ++ && IN_RANGE (INTVAL (ops3.value), rangelo, rangehi)) ++ ops3.value = GEN_INT (1 << INTVAL (ops3.value)); ++ else ++ error_opno = 2; ++ break; ++ + default: + break; + } +@@ -1864,12 +3040,14 @@ loongarch_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED, + { + case LARCH_BUILTIN_DIRECT: + case LARCH_BUILTIN_LSX: ++ case LARCH_BUILTIN_LASX: + return loongarch_expand_builtin_direct (d->icode, target, exp, true); + + case LARCH_BUILTIN_DIRECT_NO_TARGET: + return loongarch_expand_builtin_direct (d->icode, target, exp, false); + + case LARCH_BUILTIN_LSX_TEST_BRANCH: ++ case LARCH_BUILTIN_LASX_TEST_BRANCH: + return loongarch_expand_builtin_lsx_test_branch (d->icode, exp); + } + gcc_unreachable (); +diff --git a/gcc/config/loongarch/loongarch-ftypes.def b/gcc/config/loongarch/loongarch-ftypes.def +index 2b0d50892..c7f849e88 100644 +--- a/gcc/config/loongarch/loongarch-ftypes.def ++++ b/gcc/config/loongarch/loongarch-ftypes.def +@@ -67,6 +67,7 @@ DEF_LARCH_FTYPE (3, (UDI, UDI, UDI, USI)) + DEF_LARCH_FTYPE (1, (DF, DF)) + DEF_LARCH_FTYPE (2, (DF, DF, DF)) + DEF_LARCH_FTYPE (1, (DF, V2DF)) ++DEF_LARCH_FTYPE (1, (DF, V4DF)) + + DEF_LARCH_FTYPE (1, (DI, DI)) + DEF_LARCH_FTYPE (1, (DI, SI)) +@@ -83,6 +84,7 @@ DEF_LARCH_FTYPE (2, (DI, SI, SI)) + DEF_LARCH_FTYPE (2, (DI, USI, USI)) + + DEF_LARCH_FTYPE (2, (DI, V2DI, UQI)) ++DEF_LARCH_FTYPE (2, (DI, V4DI, UQI)) + + DEF_LARCH_FTYPE (2, (INT, DF, DF)) + DEF_LARCH_FTYPE (2, (INT, SF, SF)) +@@ -104,21 +106,31 @@ DEF_LARCH_FTYPE (3, (SI, SI, SI, SI)) + DEF_LARCH_FTYPE (3, (SI, SI, SI, QI)) + DEF_LARCH_FTYPE (1, (SI, UQI)) + DEF_LARCH_FTYPE (1, (SI, UV16QI)) ++DEF_LARCH_FTYPE (1, (SI, UV32QI)) + DEF_LARCH_FTYPE (1, (SI, UV2DI)) ++DEF_LARCH_FTYPE (1, (SI, UV4DI)) + DEF_LARCH_FTYPE (1, (SI, UV4SI)) ++DEF_LARCH_FTYPE (1, (SI, UV8SI)) + DEF_LARCH_FTYPE (1, (SI, UV8HI)) ++DEF_LARCH_FTYPE (1, (SI, UV16HI)) + DEF_LARCH_FTYPE (2, (SI, V16QI, UQI)) ++DEF_LARCH_FTYPE (2, (SI, V32QI, UQI)) + DEF_LARCH_FTYPE (1, (SI, V2HI)) + DEF_LARCH_FTYPE (2, (SI, V2HI, V2HI)) + DEF_LARCH_FTYPE (1, (SI, V4QI)) + DEF_LARCH_FTYPE (2, (SI, V4QI, V4QI)) + DEF_LARCH_FTYPE (2, (SI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (SI, V8SI, UQI)) + DEF_LARCH_FTYPE (2, (SI, V8HI, UQI)) + DEF_LARCH_FTYPE (1, (SI, VOID)) + + DEF_LARCH_FTYPE (2, (UDI, UDI, UDI)) ++DEF_LARCH_FTYPE (2, (USI, V32QI, UQI)) + DEF_LARCH_FTYPE (2, (UDI, UV2SI, UV2SI)) ++DEF_LARCH_FTYPE (2, (USI, V8SI, UQI)) + DEF_LARCH_FTYPE (2, (UDI, V2DI, UQI)) ++DEF_LARCH_FTYPE (2, (USI, V16HI, UQI)) ++DEF_LARCH_FTYPE (2, (UDI, V4DI, UQI)) + + DEF_LARCH_FTYPE (2, (USI, V16QI, UQI)) + DEF_LARCH_FTYPE (2, (USI, V4SI, UQI)) +@@ -142,6 +154,23 @@ DEF_LARCH_FTYPE (2, (UV2DI, UV2DI, V2DI)) + DEF_LARCH_FTYPE (2, (UV2DI, UV4SI, UV4SI)) + DEF_LARCH_FTYPE (1, (UV2DI, V2DF)) + ++DEF_LARCH_FTYPE (2, (UV32QI, UV32QI, UQI)) ++DEF_LARCH_FTYPE (2, (UV32QI, UV32QI, USI)) ++DEF_LARCH_FTYPE (2, (UV32QI, UV32QI, UV32QI)) ++DEF_LARCH_FTYPE (3, (UV32QI, UV32QI, UV32QI, UQI)) ++DEF_LARCH_FTYPE (3, (UV32QI, UV32QI, UV32QI, USI)) ++DEF_LARCH_FTYPE (3, (UV32QI, UV32QI, UV32QI, UV32QI)) ++DEF_LARCH_FTYPE (2, (UV32QI, UV32QI, V32QI)) ++ ++DEF_LARCH_FTYPE (2, (UV4DI, UV4DI, UQI)) ++DEF_LARCH_FTYPE (2, (UV4DI, UV4DI, UV4DI)) ++DEF_LARCH_FTYPE (3, (UV4DI, UV4DI, UV4DI, UQI)) ++DEF_LARCH_FTYPE (3, (UV4DI, UV4DI, UV4DI, UV4DI)) ++DEF_LARCH_FTYPE (3, (UV4DI, UV4DI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (2, (UV4DI, UV4DI, V4DI)) ++DEF_LARCH_FTYPE (2, (UV4DI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (1, (UV4DI, V4DF)) ++ + DEF_LARCH_FTYPE (2, (UV2SI, UV2SI, UQI)) + DEF_LARCH_FTYPE (2, (UV2SI, UV2SI, UV2SI)) + +@@ -170,7 +199,22 @@ DEF_LARCH_FTYPE (3, (UV8HI, UV8HI, UV8HI, UQI)) + DEF_LARCH_FTYPE (3, (UV8HI, UV8HI, UV8HI, UV8HI)) + DEF_LARCH_FTYPE (2, (UV8HI, UV8HI, V8HI)) + +- ++DEF_LARCH_FTYPE (2, (UV8SI, UV8SI, UQI)) ++DEF_LARCH_FTYPE (2, (UV8SI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (3, (UV8SI, UV8SI, UV8SI, UQI)) ++DEF_LARCH_FTYPE (3, (UV8SI, UV8SI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (3, (UV8SI, UV8SI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (2, (UV8SI, UV8SI, V8SI)) ++DEF_LARCH_FTYPE (2, (UV8SI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (1, (UV8SI, V8SF)) ++ ++DEF_LARCH_FTYPE (2, (UV16HI, UV32QI, UV32QI)) ++DEF_LARCH_FTYPE (2, (UV16HI, UV16HI, UQI)) ++DEF_LARCH_FTYPE (3, (UV16HI, UV16HI, UV32QI, UV32QI)) ++DEF_LARCH_FTYPE (2, (UV16HI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (3, (UV16HI, UV16HI, UV16HI, UQI)) ++DEF_LARCH_FTYPE (3, (UV16HI, UV16HI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (2, (UV16HI, UV16HI, V16HI)) + + DEF_LARCH_FTYPE (2, (UV8QI, UV4HI, UV4HI)) + DEF_LARCH_FTYPE (1, (UV8QI, UV8QI)) +@@ -196,6 +240,25 @@ DEF_LARCH_FTYPE (4, (V16QI, V16QI, V16QI, UQI, UQI)) + DEF_LARCH_FTYPE (3, (V16QI, V16QI, V16QI, USI)) + DEF_LARCH_FTYPE (3, (V16QI, V16QI, V16QI, V16QI)) + ++DEF_LARCH_FTYPE (2, (V32QI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (2, (V32QI, CVPOINTER, DI)) ++DEF_LARCH_FTYPE (1, (V32QI, HI)) ++DEF_LARCH_FTYPE (1, (V32QI, SI)) ++DEF_LARCH_FTYPE (2, (V32QI, UV32QI, UQI)) ++DEF_LARCH_FTYPE (2, (V32QI, UV32QI, UV32QI)) ++DEF_LARCH_FTYPE (1, (V32QI, V32QI)) ++DEF_LARCH_FTYPE (2, (V32QI, V32QI, QI)) ++DEF_LARCH_FTYPE (2, (V32QI, V32QI, SI)) ++DEF_LARCH_FTYPE (2, (V32QI, V32QI, UQI)) ++DEF_LARCH_FTYPE (2, (V32QI, V32QI, USI)) ++DEF_LARCH_FTYPE (3, (V32QI, V32QI, SI, UQI)) ++DEF_LARCH_FTYPE (3, (V32QI, V32QI, UQI, V32QI)) ++DEF_LARCH_FTYPE (2, (V32QI, V32QI, V32QI)) ++DEF_LARCH_FTYPE (3, (V32QI, V32QI, V32QI, SI)) ++DEF_LARCH_FTYPE (3, (V32QI, V32QI, V32QI, UQI)) ++DEF_LARCH_FTYPE (4, (V32QI, V32QI, V32QI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V32QI, V32QI, V32QI, USI)) ++DEF_LARCH_FTYPE (3, (V32QI, V32QI, V32QI, V32QI)) + + DEF_LARCH_FTYPE (1, (V2DF, DF)) + DEF_LARCH_FTYPE (1, (V2DF, UV2DI)) +@@ -207,6 +270,16 @@ DEF_LARCH_FTYPE (1, (V2DF, V2DI)) + DEF_LARCH_FTYPE (1, (V2DF, V4SF)) + DEF_LARCH_FTYPE (1, (V2DF, V4SI)) + ++DEF_LARCH_FTYPE (1, (V4DF, DF)) ++DEF_LARCH_FTYPE (1, (V4DF, UV4DI)) ++DEF_LARCH_FTYPE (1, (V4DF, V4DF)) ++DEF_LARCH_FTYPE (2, (V4DF, V4DF, V4DF)) ++DEF_LARCH_FTYPE (3, (V4DF, V4DF, V4DF, V4DF)) ++DEF_LARCH_FTYPE (2, (V4DF, V4DF, V4DI)) ++DEF_LARCH_FTYPE (1, (V4DF, V4DI)) ++DEF_LARCH_FTYPE (1, (V4DF, V8SF)) ++DEF_LARCH_FTYPE (1, (V4DF, V8SI)) ++ + DEF_LARCH_FTYPE (2, (V2DI, CVPOINTER, SI)) + DEF_LARCH_FTYPE (1, (V2DI, DI)) + DEF_LARCH_FTYPE (1, (V2DI, HI)) +@@ -233,6 +306,32 @@ DEF_LARCH_FTYPE (3, (V2DI, V2DI, V2DI, V2DI)) + DEF_LARCH_FTYPE (3, (V2DI, V2DI, V4SI, V4SI)) + DEF_LARCH_FTYPE (2, (V2DI, V4SI, V4SI)) + ++DEF_LARCH_FTYPE (2, (V4DI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (1, (V4DI, DI)) ++DEF_LARCH_FTYPE (1, (V4DI, HI)) ++DEF_LARCH_FTYPE (2, (V4DI, UV4DI, UQI)) ++DEF_LARCH_FTYPE (2, (V4DI, UV4DI, UV4DI)) ++DEF_LARCH_FTYPE (2, (V4DI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (1, (V4DI, V4DF)) ++DEF_LARCH_FTYPE (2, (V4DI, V4DF, V4DF)) ++DEF_LARCH_FTYPE (1, (V4DI, V4DI)) ++DEF_LARCH_FTYPE (1, (UV4DI, UV4DI)) ++DEF_LARCH_FTYPE (2, (V4DI, V4DI, QI)) ++DEF_LARCH_FTYPE (2, (V4DI, V4DI, SI)) ++DEF_LARCH_FTYPE (2, (V4DI, V4DI, UQI)) ++DEF_LARCH_FTYPE (2, (V4DI, V4DI, USI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, DI, UQI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, UQI, V4DI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (2, (V4DI, V4DI, V4DI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, V4DI, SI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, V4DI, USI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, V4DI, UQI)) ++DEF_LARCH_FTYPE (4, (V4DI, V4DI, V4DI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, V4DI, V4DI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, V8SI, V8SI)) ++DEF_LARCH_FTYPE (2, (V4DI, V8SI, V8SI)) ++ + DEF_LARCH_FTYPE (1, (V2HI, SI)) + DEF_LARCH_FTYPE (2, (V2HI, SI, SI)) + DEF_LARCH_FTYPE (3, (V2HI, SI, SI, SI)) +@@ -274,6 +373,17 @@ DEF_LARCH_FTYPE (3, (V4SF, V4SF, V4SF, V4SF)) + DEF_LARCH_FTYPE (2, (V4SF, V4SF, V4SI)) + DEF_LARCH_FTYPE (1, (V4SF, V4SI)) + DEF_LARCH_FTYPE (1, (V4SF, V8HI)) ++DEF_LARCH_FTYPE (1, (V8SF, V16HI)) ++ ++DEF_LARCH_FTYPE (1, (V8SF, SF)) ++DEF_LARCH_FTYPE (1, (V8SF, UV8SI)) ++DEF_LARCH_FTYPE (2, (V8SF, V4DF, V4DF)) ++DEF_LARCH_FTYPE (1, (V8SF, V8SF)) ++DEF_LARCH_FTYPE (2, (V8SF, V8SF, V8SF)) ++DEF_LARCH_FTYPE (3, (V8SF, V8SF, V8SF, V8SF)) ++DEF_LARCH_FTYPE (2, (V8SF, V8SF, V8SI)) ++DEF_LARCH_FTYPE (1, (V8SF, V8SI)) ++DEF_LARCH_FTYPE (1, (V8SF, V8HI)) + + DEF_LARCH_FTYPE (2, (V4SI, CVPOINTER, SI)) + DEF_LARCH_FTYPE (1, (V4SI, HI)) +@@ -282,6 +392,7 @@ DEF_LARCH_FTYPE (2, (V4SI, UV4SI, UQI)) + DEF_LARCH_FTYPE (2, (V4SI, UV4SI, UV4SI)) + DEF_LARCH_FTYPE (2, (V4SI, UV8HI, UV8HI)) + DEF_LARCH_FTYPE (2, (V4SI, V2DF, V2DF)) ++DEF_LARCH_FTYPE (2, (V8SI, V4DF, V4DF)) + DEF_LARCH_FTYPE (1, (V4SI, V4SF)) + DEF_LARCH_FTYPE (2, (V4SI, V4SF, V4SF)) + DEF_LARCH_FTYPE (1, (V4SI, V4SI)) +@@ -301,6 +412,32 @@ DEF_LARCH_FTYPE (3, (V4SI, V4SI, V4SI, V4SI)) + DEF_LARCH_FTYPE (3, (V4SI, V4SI, V8HI, V8HI)) + DEF_LARCH_FTYPE (2, (V4SI, V8HI, V8HI)) + ++DEF_LARCH_FTYPE (2, (V8SI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (1, (V8SI, HI)) ++DEF_LARCH_FTYPE (1, (V8SI, SI)) ++DEF_LARCH_FTYPE (2, (V8SI, UV8SI, UQI)) ++DEF_LARCH_FTYPE (2, (V8SI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (2, (V8SI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (2, (V8SI, V2DF, V2DF)) ++DEF_LARCH_FTYPE (1, (V8SI, V8SF)) ++DEF_LARCH_FTYPE (2, (V8SI, V8SF, V8SF)) ++DEF_LARCH_FTYPE (1, (V8SI, V8SI)) ++DEF_LARCH_FTYPE (2, (V8SI, V8SI, QI)) ++DEF_LARCH_FTYPE (2, (V8SI, V8SI, SI)) ++DEF_LARCH_FTYPE (2, (V8SI, V8SI, UQI)) ++DEF_LARCH_FTYPE (2, (V8SI, V8SI, USI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, SI, UQI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, UQI, V8SI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (2, (V8SI, V8SI, V8SI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, V8SI, SI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, V8SI, UQI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, V8SI, USI)) ++DEF_LARCH_FTYPE (4, (V8SI, V8SI, V8SI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, V8SI, V8SI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, V16HI, V16HI)) ++DEF_LARCH_FTYPE (2, (V8SI, V16HI, V16HI)) ++ + DEF_LARCH_FTYPE (2, (V8HI, CVPOINTER, SI)) + DEF_LARCH_FTYPE (1, (V8HI, HI)) + DEF_LARCH_FTYPE (1, (V8HI, SI)) +@@ -326,6 +463,31 @@ DEF_LARCH_FTYPE (4, (V8HI, V8HI, V8HI, UQI, UQI)) + DEF_LARCH_FTYPE (3, (V8HI, V8HI, V8HI, USI)) + DEF_LARCH_FTYPE (3, (V8HI, V8HI, V8HI, V8HI)) + ++DEF_LARCH_FTYPE (2, (V16HI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (1, (V16HI, HI)) ++DEF_LARCH_FTYPE (1, (V16HI, SI)) ++DEF_LARCH_FTYPE (2, (V16HI, UV32QI, UV32QI)) ++DEF_LARCH_FTYPE (2, (V16HI, UV16HI, UQI)) ++DEF_LARCH_FTYPE (2, (V16HI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (2, (V16HI, V32QI, V32QI)) ++DEF_LARCH_FTYPE (2, (V16HI, V8SF, V8SF)) ++DEF_LARCH_FTYPE (1, (V16HI, V16HI)) ++DEF_LARCH_FTYPE (2, (V16HI, V16HI, QI)) ++DEF_LARCH_FTYPE (2, (V16HI, V16HI, SI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, SI, UQI)) ++DEF_LARCH_FTYPE (2, (V16HI, V16HI, UQI)) ++DEF_LARCH_FTYPE (2, (V16HI, V16HI, USI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, UQI, SI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, UQI, V16HI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, UV32QI, UV32QI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, V32QI, V32QI)) ++DEF_LARCH_FTYPE (2, (V16HI, V16HI, V16HI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, V16HI, SI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, V16HI, UQI)) ++DEF_LARCH_FTYPE (4, (V16HI, V16HI, V16HI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, V16HI, USI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, V16HI, V16HI)) ++ + DEF_LARCH_FTYPE (2, (V8QI, V4HI, V4HI)) + DEF_LARCH_FTYPE (1, (V8QI, V8QI)) + DEF_LARCH_FTYPE (2, (V8QI, V8QI, V8QI)) +@@ -337,62 +499,113 @@ DEF_LARCH_FTYPE (2, (VOID, USI, UQI)) + DEF_LARCH_FTYPE (1, (VOID, UHI)) + DEF_LARCH_FTYPE (3, (VOID, V16QI, CVPOINTER, SI)) + DEF_LARCH_FTYPE (3, (VOID, V16QI, CVPOINTER, DI)) ++DEF_LARCH_FTYPE (3, (VOID, V32QI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V32QI, CVPOINTER, DI)) ++DEF_LARCH_FTYPE (3, (VOID, V4DF, POINTER, SI)) + DEF_LARCH_FTYPE (3, (VOID, V2DF, POINTER, SI)) + DEF_LARCH_FTYPE (3, (VOID, V2DI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V4DI, CVPOINTER, SI)) + DEF_LARCH_FTYPE (2, (VOID, V2HI, V2HI)) + DEF_LARCH_FTYPE (2, (VOID, V4QI, V4QI)) + DEF_LARCH_FTYPE (3, (VOID, V4SF, POINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V8SF, POINTER, SI)) + DEF_LARCH_FTYPE (3, (VOID, V4SI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V8SI, CVPOINTER, SI)) + DEF_LARCH_FTYPE (3, (VOID, V8HI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V16HI, CVPOINTER, SI)) + ++DEF_LARCH_FTYPE (1, (V16HI, V32QI)) ++DEF_LARCH_FTYPE (1, (UV16HI, UV32QI)) ++DEF_LARCH_FTYPE (1, (V8SI, V32QI)) ++DEF_LARCH_FTYPE (1, (V4DI, V32QI)) + DEF_LARCH_FTYPE (1, (V8HI, V16QI)) + DEF_LARCH_FTYPE (1, (V4SI, V16QI)) + DEF_LARCH_FTYPE (1, (V2DI, V16QI)) ++DEF_LARCH_FTYPE (1, (UV8SI, UV16HI)) ++DEF_LARCH_FTYPE (1, (V8SI, V16HI)) ++DEF_LARCH_FTYPE (1, (V4DI, V16HI)) + DEF_LARCH_FTYPE (1, (V4SI, V8HI)) + DEF_LARCH_FTYPE (1, (V2DI, V8HI)) + DEF_LARCH_FTYPE (1, (V2DI, V4SI)) ++DEF_LARCH_FTYPE (1, (V4DI, V8SI)) ++DEF_LARCH_FTYPE (1, (UV4DI, UV8SI)) ++DEF_LARCH_FTYPE (1, (UV16HI, V32QI)) ++DEF_LARCH_FTYPE (1, (UV8SI, V32QI)) ++DEF_LARCH_FTYPE (1, (UV4DI, V32QI)) + DEF_LARCH_FTYPE (1, (UV8HI, V16QI)) + DEF_LARCH_FTYPE (1, (UV4SI, V16QI)) + DEF_LARCH_FTYPE (1, (UV2DI, V16QI)) ++DEF_LARCH_FTYPE (1, (UV8SI, V16HI)) ++DEF_LARCH_FTYPE (1, (UV4DI, V16HI)) + DEF_LARCH_FTYPE (1, (UV4SI, V8HI)) + DEF_LARCH_FTYPE (1, (UV2DI, V8HI)) + DEF_LARCH_FTYPE (1, (UV2DI, V4SI)) ++DEF_LARCH_FTYPE (1, (UV4DI, V8SI)) + DEF_LARCH_FTYPE (1, (UV8HI, UV16QI)) + DEF_LARCH_FTYPE (1, (UV4SI, UV16QI)) + DEF_LARCH_FTYPE (1, (UV2DI, UV16QI)) ++DEF_LARCH_FTYPE (1, (UV4DI, UV32QI)) + DEF_LARCH_FTYPE (1, (UV4SI, UV8HI)) + DEF_LARCH_FTYPE (1, (UV2DI, UV8HI)) + DEF_LARCH_FTYPE (1, (UV2DI, UV4SI)) + DEF_LARCH_FTYPE (2, (UV8HI, V16QI, V16QI)) + DEF_LARCH_FTYPE (2, (UV4SI, V8HI, V8HI)) + DEF_LARCH_FTYPE (2, (UV2DI, V4SI, V4SI)) ++DEF_LARCH_FTYPE (2, (V16HI, V32QI, UQI)) ++DEF_LARCH_FTYPE (2, (V8SI, V16HI, UQI)) ++DEF_LARCH_FTYPE (2, (V4DI, V8SI, UQI)) + DEF_LARCH_FTYPE (2, (V8HI, V16QI, UQI)) + DEF_LARCH_FTYPE (2, (V4SI, V8HI, UQI)) + DEF_LARCH_FTYPE (2, (V2DI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (UV16HI, UV32QI, UQI)) ++DEF_LARCH_FTYPE (2, (UV8SI, UV16HI, UQI)) ++DEF_LARCH_FTYPE (2, (UV4DI, UV8SI, UQI)) + DEF_LARCH_FTYPE (2, (UV8HI, UV16QI, UQI)) + DEF_LARCH_FTYPE (2, (UV4SI, UV8HI, UQI)) + DEF_LARCH_FTYPE (2, (UV2DI, UV4SI, UQI)) ++DEF_LARCH_FTYPE (2, (V32QI, V16HI, V16HI)) ++DEF_LARCH_FTYPE (2, (V16HI, V8SI, V8SI)) ++DEF_LARCH_FTYPE (2, (V8SI, V4DI, V4DI)) + DEF_LARCH_FTYPE (2, (V16QI, V8HI, V8HI)) + DEF_LARCH_FTYPE (2, (V8HI, V4SI, V4SI)) + DEF_LARCH_FTYPE (2, (V4SI, V2DI, V2DI)) ++DEF_LARCH_FTYPE (2, (UV32QI, UV16HI, UV16HI)) ++DEF_LARCH_FTYPE (2, (UV16HI, UV8SI, UV8SI)) ++DEF_LARCH_FTYPE (2, (UV8SI, UV4DI, UV4DI)) + DEF_LARCH_FTYPE (2, (UV16QI, UV8HI, UV8HI)) + DEF_LARCH_FTYPE (2, (UV8HI, UV4SI, UV4SI)) + DEF_LARCH_FTYPE (2, (UV4SI, UV2DI, UV2DI)) ++DEF_LARCH_FTYPE (2, (V32QI, V16HI, UQI)) ++DEF_LARCH_FTYPE (2, (V16HI, V8SI, UQI)) ++DEF_LARCH_FTYPE (2, (V8SI, V4DI, UQI)) + DEF_LARCH_FTYPE (2, (V16QI, V8HI, UQI)) + DEF_LARCH_FTYPE (2, (V8HI, V4SI, UQI)) + DEF_LARCH_FTYPE (2, (V4SI, V2DI, UQI)) ++DEF_LARCH_FTYPE (2, (UV32QI, UV16HI, UQI)) ++DEF_LARCH_FTYPE (2, (UV16HI, UV8SI, UQI)) ++DEF_LARCH_FTYPE (2, (UV8SI, UV4DI, UQI)) + DEF_LARCH_FTYPE (2, (UV16QI, UV8HI, UQI)) + DEF_LARCH_FTYPE (2, (UV8HI, UV4SI, UQI)) + DEF_LARCH_FTYPE (2, (UV4SI, UV2DI, UQI)) ++DEF_LARCH_FTYPE (2, (V32QI, V32QI, DI)) + DEF_LARCH_FTYPE (2, (V16QI, V16QI, DI)) ++DEF_LARCH_FTYPE (2, (V32QI, UQI, UQI)) + DEF_LARCH_FTYPE (2, (V16QI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V32QI, V32QI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V16HI, V16HI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V8SI, V8SI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V4DI, V4DI, UQI, UQI)) + DEF_LARCH_FTYPE (3, (V16QI, V16QI, UQI, UQI)) + DEF_LARCH_FTYPE (3, (V8HI, V8HI, UQI, UQI)) + DEF_LARCH_FTYPE (3, (V4SI, V4SI, UQI, UQI)) + DEF_LARCH_FTYPE (3, (V2DI, V2DI, UQI, UQI)) ++DEF_LARCH_FTYPE (2, (V8SF, V4DI, V4DI)) + DEF_LARCH_FTYPE (2, (V4SF, V2DI, V2DI)) ++DEF_LARCH_FTYPE (1, (V4DI, V8SF)) + DEF_LARCH_FTYPE (1, (V2DI, V4SF)) ++DEF_LARCH_FTYPE (2, (V4DI, UQI, USI)) + DEF_LARCH_FTYPE (2, (V2DI, UQI, USI)) ++DEF_LARCH_FTYPE (2, (V4DI, UQI, UQI)) + DEF_LARCH_FTYPE (2, (V2DI, UQI, UQI)) + DEF_LARCH_FTYPE (4, (VOID, SI, UQI, V16QI, CVPOINTER)) + DEF_LARCH_FTYPE (4, (VOID, SI, UQI, V8HI, CVPOINTER)) +@@ -402,6 +615,17 @@ DEF_LARCH_FTYPE (2, (V16QI, SI, CVPOINTER)) + DEF_LARCH_FTYPE (2, (V8HI, SI, CVPOINTER)) + DEF_LARCH_FTYPE (2, (V4SI, SI, CVPOINTER)) + DEF_LARCH_FTYPE (2, (V2DI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (4, (VOID, V32QI, UQI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (4, (VOID, V16HI, UQI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (4, (VOID, V8SI, UQI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (4, (VOID, V4DI, UQI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (3, (VOID, V32QI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V32QI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V16HI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V8SI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V4DI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (1, (V32QI, POINTER)) ++DEF_LARCH_FTYPE (2, (VOID, V32QI, POINTER)) + DEF_LARCH_FTYPE (2, (V8HI, UV16QI, V16QI)) + DEF_LARCH_FTYPE (2, (V16QI, V16QI, UV16QI)) + DEF_LARCH_FTYPE (2, (UV16QI, V16QI, UV16QI)) +@@ -431,6 +655,33 @@ DEF_LARCH_FTYPE (3, (V4SI, V4SI, V16QI, V16QI)) + DEF_LARCH_FTYPE (3, (V4SI, V4SI, UV16QI, V16QI)) + DEF_LARCH_FTYPE (3, (UV4SI, UV4SI, UV16QI, UV16QI)) + ++ ++DEF_LARCH_FTYPE(2,(V4DI,V16HI,V16HI)) ++DEF_LARCH_FTYPE(2,(V4DI,UV4SI,V4SI)) ++DEF_LARCH_FTYPE(2,(V8SI,UV16HI,V16HI)) ++DEF_LARCH_FTYPE(2,(V16HI,UV32QI,V32QI)) ++DEF_LARCH_FTYPE(2,(V4DI,UV8SI,V8SI)) ++DEF_LARCH_FTYPE(3,(V4DI,V4DI,V16HI,V16HI)) ++DEF_LARCH_FTYPE(2,(UV32QI,V32QI,UV32QI)) ++DEF_LARCH_FTYPE(2,(UV16HI,V16HI,UV16HI)) ++DEF_LARCH_FTYPE(2,(UV8SI,V8SI,UV8SI)) ++DEF_LARCH_FTYPE(2,(UV4DI,V4DI,UV4DI)) ++DEF_LARCH_FTYPE(3,(V4DI,V4DI,UV4DI,V4DI)) ++DEF_LARCH_FTYPE(3,(V4DI,V4DI,UV8SI,V8SI)) ++DEF_LARCH_FTYPE(3,(V8SI,V8SI,UV16HI,V16HI)) ++DEF_LARCH_FTYPE(3,(V16HI,V16HI,UV32QI,V32QI)) ++DEF_LARCH_FTYPE(2,(V4DI,UV4DI,V4DI)) ++DEF_LARCH_FTYPE(2,(V8SI,V32QI,V32QI)) ++DEF_LARCH_FTYPE(2,(UV4DI,UV16HI,UV16HI)) ++DEF_LARCH_FTYPE(2,(V4DI,UV16HI,V16HI)) ++DEF_LARCH_FTYPE(3,(V8SI,V8SI,V32QI,V32QI)) ++DEF_LARCH_FTYPE(3,(UV8SI,UV8SI,UV32QI,UV32QI)) ++DEF_LARCH_FTYPE(3,(UV4DI,UV4DI,UV16HI,UV16HI)) ++DEF_LARCH_FTYPE(3,(V8SI,V8SI,UV32QI,V32QI)) ++DEF_LARCH_FTYPE(3,(V4DI,V4DI,UV16HI,V16HI)) ++DEF_LARCH_FTYPE(2,(UV8SI,UV32QI,UV32QI)) ++DEF_LARCH_FTYPE(2,(V8SI,UV32QI,V32QI)) ++ + DEF_LARCH_FTYPE(4,(VOID,V16QI,CVPOINTER,SI,UQI)) + DEF_LARCH_FTYPE(4,(VOID,V8HI,CVPOINTER,SI,UQI)) + DEF_LARCH_FTYPE(4,(VOID,V4SI,CVPOINTER,SI,UQI)) +@@ -448,11 +699,29 @@ DEF_LARCH_FTYPE (3, (UV8HI, UV8HI, V8HI, USI)) + DEF_LARCH_FTYPE (3, (UV4SI, UV4SI, V4SI, USI)) + DEF_LARCH_FTYPE (3, (UV2DI, UV2DI, V2DI, USI)) + ++DEF_LARCH_FTYPE (2, (DI, V8SI, UQI)) ++DEF_LARCH_FTYPE (2, (UDI, V8SI, UQI)) ++ ++DEF_LARCH_FTYPE (3, (UV32QI, UV32QI, V32QI, USI)) ++DEF_LARCH_FTYPE (3, (UV16HI, UV16HI, V16HI, USI)) ++DEF_LARCH_FTYPE (3, (UV8SI, UV8SI, V8SI, USI)) ++DEF_LARCH_FTYPE (3, (UV4DI, UV4DI, V4DI, USI)) ++ ++DEF_LARCH_FTYPE(4,(VOID,V32QI,CVPOINTER,SI,UQI)) ++DEF_LARCH_FTYPE(4,(VOID,V16HI,CVPOINTER,SI,UQI)) ++DEF_LARCH_FTYPE(4,(VOID,V8SI,CVPOINTER,SI,UQI)) ++DEF_LARCH_FTYPE(4,(VOID,V4DI,CVPOINTER,SI,UQI)) ++ + DEF_LARCH_FTYPE (1, (BOOLEAN,V16QI)) + DEF_LARCH_FTYPE(2,(V16QI,CVPOINTER,CVPOINTER)) + DEF_LARCH_FTYPE(3,(VOID,V16QI,CVPOINTER,CVPOINTER)) ++DEF_LARCH_FTYPE(2,(V32QI,CVPOINTER,CVPOINTER)) ++DEF_LARCH_FTYPE(3,(VOID,V32QI,CVPOINTER,CVPOINTER)) + + DEF_LARCH_FTYPE (3, (V16QI, V16QI, SI, UQI)) + DEF_LARCH_FTYPE (3, (V2DI, V2DI, SI, UQI)) + DEF_LARCH_FTYPE (3, (V2DI, V2DI, DI, UQI)) + DEF_LARCH_FTYPE (3, (V4SI, V4SI, SI, UQI)) ++ ++DEF_LARCH_FTYPE (2, (V8SF, V8SF, UQI)) ++DEF_LARCH_FTYPE (2, (V4DF, V4DF, UQI)) +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-Loongson-SX-base-instruction-support.patch
Added
@@ -0,0 +1,8433 @@ +From 0b4626bb55886081e90922cf6d6869d551847a47 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 16 Mar 2023 16:29:42 +0800 +Subject: PATCH 063/124 LoongArch: Add Loongson SX base instruction support. + +gcc/ChangeLog: + + * config/loongarch/constraints.md (M): Add Loongson LSX base instruction support. + (N): Ditto. + (O): Ditto. + (P): Ditto. + (R): Ditto. + (S): Ditto. + (YG): Ditto. + (YA): Ditto. + (YB): Ditto. + (Yb): Ditto. + (Yh): Ditto. + (Yw): Ditto. + (YI): Ditto. + (YC): Ditto. + (YZ): Ditto. + (Unv5): Ditto. + (Uuv5): Ditto. + (Usv5): Ditto. + (Uuv6): Ditto. + (Urv8): Ditto. + * config/loongarch/genopts/loongarch.opt.in: Ditto. + * config/loongarch/loongarch-builtins.cc (loongarch_gen_const_int_vector): Ditto. + * config/loongarch/loongarch-modes.def (VECTOR_MODES): Ditto. + (VECTOR_MODE): Ditto. + (INT_MODE): Ditto. + * config/loongarch/loongarch-protos.h (loongarch_split_move_insn_p): Ditto. + (loongarch_split_move_insn): Ditto. + (loongarch_split_128bit_move): Ditto. + (loongarch_split_128bit_move_p): Ditto. + (loongarch_split_lsx_copy_d): Ditto. + (loongarch_split_lsx_insert_d): Ditto. + (loongarch_split_lsx_fill_d): Ditto. + (loongarch_expand_vec_cmp): Ditto. + (loongarch_const_vector_same_val_p): Ditto. + (loongarch_const_vector_same_bytes_p): Ditto. + (loongarch_const_vector_same_int_p): Ditto. + (loongarch_const_vector_shuffle_set_p): Ditto. + (loongarch_const_vector_bitimm_set_p): Ditto. + (loongarch_const_vector_bitimm_clr_p): Ditto. + (loongarch_lsx_vec_parallel_const_half): Ditto. + (loongarch_gen_const_int_vector): Ditto. + (loongarch_lsx_output_division): Ditto. + (loongarch_expand_vector_init): Ditto. + (loongarch_expand_vec_unpack): Ditto. + (loongarch_expand_vec_perm): Ditto. + (loongarch_expand_vector_extract): Ditto. + (loongarch_expand_vector_reduc): Ditto. + (loongarch_ldst_scaled_shift): Ditto. + (loongarch_expand_vec_cond_expr): Ditto. + (loongarch_expand_vec_cond_mask_expr): Ditto. + (loongarch_builtin_vectorized_function): Ditto. + (loongarch_gen_const_int_vector_shuffle): Ditto. + (loongarch_build_signbit_mask): Ditto. + * config/loongarch/loongarch.cc (loongarch_pass_aggregate_num_fpr): Ditto. + (loongarch_setup_incoming_varargs): Ditto. + (loongarch_emit_move): Ditto. + (loongarch_const_vector_bitimm_set_p): Ditto. + (loongarch_const_vector_bitimm_clr_p): Ditto. + (loongarch_const_vector_same_val_p): Ditto. + (loongarch_const_vector_same_bytes_p): Ditto. + (loongarch_const_vector_same_int_p): Ditto. + (loongarch_const_vector_shuffle_set_p): Ditto. + (loongarch_symbol_insns): Ditto. + (loongarch_cannot_force_const_mem): Ditto. + (loongarch_valid_offset_p): Ditto. + (loongarch_valid_index_p): Ditto. + (loongarch_classify_address): Ditto. + (loongarch_address_insns): Ditto. + (loongarch_ldst_scaled_shift): Ditto. + (loongarch_const_insns): Ditto. + (loongarch_split_move_insn_p): Ditto. + (loongarch_subword_at_byte): Ditto. + (loongarch_legitimize_move): Ditto. + (loongarch_builtin_vectorization_cost): Ditto. + (loongarch_split_move_p): Ditto. + (loongarch_split_move): Ditto. + (loongarch_split_move_insn): Ditto. + (loongarch_output_move_index_float): Ditto. + (loongarch_split_128bit_move_p): Ditto. + (loongarch_split_128bit_move): Ditto. + (loongarch_split_lsx_copy_d): Ditto. + (loongarch_split_lsx_insert_d): Ditto. + (loongarch_split_lsx_fill_d): Ditto. + (loongarch_output_move): Ditto. + (loongarch_extend_comparands): Ditto. + (loongarch_print_operand_reloc): Ditto. + (loongarch_print_operand): Ditto. + (loongarch_hard_regno_mode_ok_uncached): Ditto. + (loongarch_hard_regno_call_part_clobbered): Ditto. + (loongarch_hard_regno_nregs): Ditto. + (loongarch_class_max_nregs): Ditto. + (loongarch_can_change_mode_class): Ditto. + (loongarch_mode_ok_for_mov_fmt_p): Ditto. + (loongarch_secondary_reload): Ditto. + (loongarch_vector_mode_supported_p): Ditto. + (loongarch_preferred_simd_mode): Ditto. + (loongarch_autovectorize_vector_modes): Ditto. + (loongarch_lsx_output_division): Ditto. + (loongarch_option_override_internal): Ditto. + (loongarch_hard_regno_caller_save_mode): Ditto. + (MAX_VECT_LEN): Ditto. + (loongarch_spill_class): Ditto. + (struct expand_vec_perm_d): Ditto. + (loongarch_promote_function_mode): Ditto. + (loongarch_expand_vselect): Ditto. + (loongarch_starting_frame_offset): Ditto. + (loongarch_expand_vselect_vconcat): Ditto. + (TARGET_ASM_ALIGNED_DI_OP): Ditto. + (TARGET_OPTION_OVERRIDE): Ditto. + (TARGET_LEGITIMIZE_ADDRESS): Ditto. + (TARGET_ASM_SELECT_RTX_SECTION): Ditto. + (TARGET_ASM_FUNCTION_RODATA_SECTION): Ditto. + (loongarch_expand_lsx_shuffle): Ditto. + (TARGET_SCHED_INIT): Ditto. + (TARGET_SCHED_REORDER): Ditto. + (TARGET_SCHED_REORDER2): Ditto. + (TARGET_SCHED_VARIABLE_ISSUE): Ditto. + (TARGET_SCHED_ADJUST_COST): Ditto. + (TARGET_SCHED_ISSUE_RATE): Ditto. + (TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD): Ditto. + (TARGET_FUNCTION_OK_FOR_SIBCALL): Ditto. + (TARGET_VALID_POINTER_MODE): Ditto. + (TARGET_REGISTER_MOVE_COST): Ditto. + (TARGET_MEMORY_MOVE_COST): Ditto. + (TARGET_RTX_COSTS): Ditto. + (TARGET_ADDRESS_COST): Ditto. + (TARGET_IN_SMALL_DATA_P): Ditto. + (TARGET_PREFERRED_RELOAD_CLASS): Ditto. + (TARGET_ASM_FILE_START_FILE_DIRECTIVE): Ditto. + (TARGET_EXPAND_BUILTIN_VA_START): Ditto. + (loongarch_expand_vec_perm): Ditto. + (TARGET_PROMOTE_FUNCTION_MODE): Ditto. + (TARGET_RETURN_IN_MEMORY): Ditto. + (TARGET_FUNCTION_VALUE): Ditto. + (TARGET_LIBCALL_VALUE): Ditto. + (loongarch_try_expand_lsx_vshuf_const): Ditto. + (TARGET_ASM_OUTPUT_MI_THUNK): Ditto. + (TARGET_ASM_CAN_OUTPUT_MI_THUNK): Ditto. + (TARGET_PRINT_OPERAND): Ditto. + (TARGET_PRINT_OPERAND_ADDRESS): Ditto. + (TARGET_PRINT_OPERAND_PUNCT_VALID_P): Ditto. + (TARGET_SETUP_INCOMING_VARARGS): Ditto. + (TARGET_STRICT_ARGUMENT_NAMING): Ditto. + (TARGET_MUST_PASS_IN_STACK): Ditto. + (TARGET_PASS_BY_REFERENCE): Ditto. + (TARGET_ARG_PARTIAL_BYTES): Ditto. + (TARGET_FUNCTION_ARG): Ditto. + (TARGET_FUNCTION_ARG_ADVANCE): Ditto. + (TARGET_FUNCTION_ARG_BOUNDARY): Ditto. + (TARGET_SCALAR_MODE_SUPPORTED_P): Ditto. + (TARGET_INIT_BUILTINS): Ditto. + (loongarch_expand_vec_perm_const_1): Ditto. + (loongarch_expand_vec_perm_const_2): Ditto. + (loongarch_vectorize_vec_perm_const): Ditto. + (loongarch_cpu_sched_reassociation_width): Ditto. + (loongarch_sched_reassociation_width): Ditto. + (loongarch_expand_vector_extract): Ditto. + (emit_reduc_half): Ditto. + (loongarch_expand_vector_reduc): Ditto. + (loongarch_expand_vec_unpack): Ditto. + (loongarch_lsx_vec_parallel_const_half): Ditto. + (loongarch_constant_elt_p): Ditto. + (loongarch_gen_const_int_vector_shuffle): Ditto. + (loongarch_expand_vector_init): Ditto. + (loongarch_expand_lsx_cmp): Ditto. + (loongarch_expand_vec_cond_expr): Ditto. + (loongarch_expand_vec_cond_mask_expr): Ditto. + (loongarch_expand_vec_cmp): Ditto. + (loongarch_case_values_threshold): Ditto. + (loongarch_build_const_vector): Ditto. + (loongarch_build_signbit_mask): Ditto. + (loongarch_builtin_support_vector_misalignment): Ditto. + (TARGET_ASM_ALIGNED_HI_OP): Ditto. + (TARGET_ASM_ALIGNED_SI_OP): Ditto. + (TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST): Ditto. + (TARGET_VECTOR_MODE_SUPPORTED_P): Ditto. + (TARGET_VECTORIZE_PREFERRED_SIMD_MODE): Ditto. + (TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): Ditto. + (TARGET_VECTORIZE_VEC_PERM_CONST): Ditto. + (TARGET_SCHED_REASSOCIATION_WIDTH): Ditto. + (TARGET_CASE_VALUES_THRESHOLD): Ditto. + (TARGET_HARD_REGNO_CALL_PART_CLOBBERED): Ditto. + (TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT): Ditto. + * config/loongarch/loongarch.h (TARGET_SUPPORTS_WIDE_INT): Ditto. + (UNITS_PER_LSX_REG): Ditto. + (BITS_PER_LSX_REG): Ditto. + (BIGGEST_ALIGNMENT): Ditto. + (LSX_REG_FIRST): Ditto. + (LSX_REG_LAST): Ditto. + (LSX_REG_NUM): Ditto. + (LSX_REG_P): Ditto. + (LSX_REG_RTX_P): Ditto. + (IMM13_OPERAND): Ditto. + (LSX_SUPPORTED_MODE_P): Ditto. + * config/loongarch/loongarch.md (unknown,add,sub,not,nor,and,or,xor): Ditto. + (unknown,add,sub,not,nor,and,or,xor,simd_add): Ditto. + (unknown,none,QI,HI,SI,DI,TI,SF,DF,TF,FCC): Ditto. + (mode" ): Ditto. + (DF): Ditto. + (SF): Ditto. + (sf): Ditto. + (DI): Ditto. + (SI): Ditto. + * config/loongarch/loongarch.opt: Ditto. + * config/loongarch/predicates.md (const_lsx_branch_operand): Ditto. + (const_uimm3_operand): Ditto. + (const_8_to_11_operand): Ditto. + (const_12_to_15_operand): Ditto. + (const_uimm4_operand): Ditto. + (const_uimm6_operand): Ditto. + (const_uimm7_operand): Ditto. + (const_uimm8_operand): Ditto. + (const_imm5_operand): Ditto. + (const_imm10_operand): Ditto. + (const_imm13_operand): Ditto. + (reg_imm10_operand): Ditto. + (aq8b_operand): Ditto. + (aq8h_operand): Ditto. + (aq8w_operand): Ditto. + (aq8d_operand): Ditto. + (aq10b_operand): Ditto. + (aq10h_operand): Ditto. + (aq10w_operand): Ditto. + (aq10d_operand): Ditto. + (aq12b_operand): Ditto. + (aq12h_operand): Ditto. + (aq12w_operand): Ditto. + (aq12d_operand): Ditto. + (const_m1_operand): Ditto. + (reg_or_m1_operand): Ditto. + (const_exp_2_operand): Ditto. + (const_exp_4_operand): Ditto. + (const_exp_8_operand): Ditto. + (const_exp_16_operand): Ditto. + (const_exp_32_operand): Ditto. + (const_0_or_1_operand): Ditto. + (const_0_to_3_operand): Ditto. + (const_0_to_7_operand): Ditto. + (const_2_or_3_operand): Ditto. + (const_4_to_7_operand): Ditto. + (const_8_to_15_operand): Ditto. + (const_16_to_31_operand): Ditto. + (qi_mask_operand): Ditto. + (hi_mask_operand): Ditto. + (si_mask_operand): Ditto. + (d_operand): Ditto. + (db4_operand): Ditto. + (db7_operand): Ditto. + (db8_operand): Ditto. + (ib3_operand): Ditto. + (sb4_operand): Ditto. + (sb5_operand): Ditto. + (sb8_operand): Ditto. + (sd8_operand): Ditto. + (ub4_operand): Ditto. + (ub8_operand): Ditto. + (uh4_operand): Ditto. + (uw4_operand): Ditto. + (uw5_operand): Ditto. + (uw6_operand): Ditto. + (uw8_operand): Ditto. + (addiur2_operand): Ditto. + (addiusp_operand): Ditto. + (andi16_operand): Ditto. + (movep_src_register): Ditto. + (movep_src_operand): Ditto. + (fcc_reload_operand): Ditto. + (muldiv_target_operand): Ditto. + (const_vector_same_val_operand): Ditto. + (const_vector_same_simm5_operand): Ditto. + (const_vector_same_uimm5_operand): Ditto. + (const_vector_same_ximm5_operand): Ditto. + (const_vector_same_uimm6_operand): Ditto. + (par_const_vector_shf_set_operand): Ditto. + (reg_or_vector_same_val_operand): Ditto. + (reg_or_vector_same_simm5_operand): Ditto. + (reg_or_vector_same_uimm5_operand): Ditto. + (reg_or_vector_same_ximm5_operand): Ditto. + (reg_or_vector_same_uimm6_operand): Ditto. + * doc/md.texi: Ditto. + * config/loongarch/lsx.md: New file. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/constraints.md | 131 +- + gcc/config/loongarch/genopts/loongarch.opt.in | 4 + + gcc/config/loongarch/loongarch-builtins.cc | 10 + + gcc/config/loongarch/loongarch-modes.def | 38 + + gcc/config/loongarch/loongarch-protos.h | 31 + + gcc/config/loongarch/loongarch.cc | 2226 +++++++- + gcc/config/loongarch/loongarch.h | 65 +- + gcc/config/loongarch/loongarch.md | 44 +- + gcc/config/loongarch/loongarch.opt | 4 + + gcc/config/loongarch/lsx.md | 4467 +++++++++++++++++ + gcc/config/loongarch/predicates.md | 333 +- + gcc/doc/md.texi | 11 + + 12 files changed, 7181 insertions(+), 183 deletions(-) + create mode 100644 gcc/config/loongarch/lsx.md + +diff --git a/gcc/config/loongarch/constraints.md b/gcc/config/loongarch/constraints.md +index 25f3cda35..cec5d8857 100644 +--- a/gcc/config/loongarch/constraints.md ++++ b/gcc/config/loongarch/constraints.md +@@ -76,12 +76,13 @@ + ;; "Le" + ;; "A signed 32-bit constant can be expressed as Lb + I, but not a + ;; single Lb or I." +-;; "M" <-----unused +-;; "N" <-----unused +-;; "O" <-----unused +-;; "P" <-----unused ++;; "M" "A constant that cannot be loaded using @code{lui}, @code{addiu} ++;; or @code{ori}." ++;; "N" "A constant in the range -65535 to -1 (inclusive)." ++;; "O" "A signed 15-bit constant." ++;; "P" "A constant in the range 1 to 65535 (inclusive)." + ;; "Q" <-----unused +-;; "R" <-----unused ++;; "R" "An address that can be used in a non-macro load or store." + ;; "S" <-----unused + ;; "T" <-----unused + ;; "U" <-----unused +@@ -214,6 +215,63 @@ + (and (match_code "const_int") + (match_test "loongarch_addu16i_imm12_operand_p (ival, SImode)"))) + ++(define_constraint "M" ++ "A constant that cannot be loaded using @code{lui}, @code{addiu} ++ or @code{ori}." ++ (and (match_code "const_int") ++ (not (match_test "IMM12_OPERAND (ival)")) ++ (not (match_test "IMM12_OPERAND_UNSIGNED (ival)")) ++ (not (match_test "LU12I_OPERAND (ival)")))) ++ ++(define_constraint "N" ++ "A constant in the range -65535 to -1 (inclusive)." ++ (and (match_code "const_int") ++ (match_test "ival >= -0xffff && ival < 0"))) ++ ++(define_constraint "O" ++ "A signed 15-bit constant." ++ (and (match_code "const_int") ++ (match_test "ival >= -0x4000 && ival < 0x4000"))) ++ ++(define_constraint "P" ++ "A constant in the range 1 to 65535 (inclusive)." ++ (and (match_code "const_int") ++ (match_test "ival > 0 && ival < 0x10000"))) ++ ++;; General constraints ++ ++(define_memory_constraint "R" ++ "An address that can be used in a non-macro load or store." ++ (and (match_code "mem") ++ (match_test "loongarch_address_insns (XEXP (op, 0), mode, false) == 1"))) ++(define_constraint "S" ++ "@internal ++ A constant call address." ++ (and (match_operand 0 "call_insn_operand") ++ (match_test "CONSTANT_P (op)"))) ++ ++(define_constraint "YG" ++ "@internal ++ A vector zero." ++ (and (match_code "const_vector") ++ (match_test "op == CONST0_RTX (mode)"))) ++ ++(define_constraint "YA" ++ "@internal ++ An unsigned 6-bit constant." ++ (and (match_code "const_int") ++ (match_test "UIMM6_OPERAND (ival)"))) ++ ++(define_constraint "YB" ++ "@internal ++ A signed 10-bit constant." ++ (and (match_code "const_int") ++ (match_test "IMM10_OPERAND (ival)"))) ++ ++(define_constraint "Yb" ++ "@internal" ++ (match_operand 0 "qi_mask_operand")) ++ + (define_constraint "Yd" + "@internal + A constant @code{move_operand} that can be safely loaded using +@@ -221,10 +279,73 @@ + (and (match_operand 0 "move_operand") + (match_test "CONSTANT_P (op)"))) + ++(define_constraint "Yh" ++ "@internal" ++ (match_operand 0 "hi_mask_operand")) ++ ++(define_constraint "Yw" ++ "@internal" ++ (match_operand 0 "si_mask_operand")) ++ + (define_constraint "Yx" + "@internal" + (match_operand 0 "low_bitmask_operand")) + ++(define_constraint "YI" ++ "@internal ++ A replicated vector const in which the replicated value is in the range ++ -512,511." ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_same_int_p (op, mode, -512, 511)"))) ++ ++(define_constraint "YC" ++ "@internal ++ A replicated vector const in which the replicated value has a single ++ bit set." ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_bitimm_set_p (op, mode)"))) ++ ++(define_constraint "YZ" ++ "@internal ++ A replicated vector const in which the replicated value has a single ++ bit clear." ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_bitimm_clr_p (op, mode)"))) ++ ++(define_constraint "Unv5" ++ "@internal ++ A replicated vector const in which the replicated value is in the range ++ -31,0." ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_same_int_p (op, mode, -31, 0)"))) ++ ++(define_constraint "Uuv5" ++ "@internal ++ A replicated vector const in which the replicated value is in the range ++ 0,31." ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_same_int_p (op, mode, 0, 31)"))) ++ ++(define_constraint "Usv5" ++ "@internal ++ A replicated vector const in which the replicated value is in the range ++ -16,15." ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_same_int_p (op, mode, -16, 15)"))) ++ ++(define_constraint "Uuv6" ++ "@internal ++ A replicated vector const in which the replicated value is in the range ++ 0,63." ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_same_int_p (op, mode, 0, 63)"))) ++ ++(define_constraint "Urv8" ++ "@internal ++ A replicated vector const with replicated byte values as well as elements" ++ (and (match_code "const_vector") ++ (match_test "loongarch_const_vector_same_bytes_p (op, mode)"))) ++ + (define_memory_constraint "ZC" + "A memory operand whose address is formed by a base register and offset + that is suitable for use in instructions with the same addressing mode +diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in +index c6e337d05..c53785a37 100644 +--- a/gcc/config/loongarch/genopts/loongarch.opt.in ++++ b/gcc/config/loongarch/genopts/loongarch.opt.in +@@ -146,6 +146,10 @@ mbranch-cost= + Target RejectNegative Joined UInteger Var(loongarch_branch_cost) + -mbranch-cost=COST Set the cost of branches to roughly COST instructions. + ++mmemvec-cost= ++Target RejectNegative Joined UInteger Var(loongarch_vector_access_cost) IntegerRange(1, 5) ++mmemvec-cost=COST Set the cost of vector memory access instructions. ++ + mcheck-zero-division + Target Mask(CHECK_ZERO_DIV) + Trap on integer divide by zero. +diff --git a/gcc/config/loongarch/loongarch-builtins.cc b/gcc/config/loongarch/loongarch-builtins.cc +index cb0ea1664..c8548a07f 100644 +--- a/gcc/config/loongarch/loongarch-builtins.cc ++++ b/gcc/config/loongarch/loongarch-builtins.cc +@@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see + #include "fold-const.h" + #include "expr.h" + #include "langhooks.h" ++#include "emit-rtl.h" + + /* Macros to create an enumeration identifier for a function prototype. */ + #define LARCH_FTYPE_NAME1(A, B) LARCH_##A##_FTYPE_##B +@@ -302,6 +303,15 @@ loongarch_prepare_builtin_arg (struct expand_operand *op, tree exp, + create_input_operand (op, value, TYPE_MODE (TREE_TYPE (arg))); + } + ++/* Return a const_int vector of VAL with mode MODE. */ ++ ++rtx ++loongarch_gen_const_int_vector (machine_mode mode, HOST_WIDE_INT val) ++{ ++ rtx c = gen_int_mode (val, GET_MODE_INNER (mode)); ++ return gen_const_vec_duplicate (mode, c); ++} ++ + /* Expand instruction ICODE as part of a built-in function sequence. + Use the first NOPS elements of OPS as the instruction's operands. + HAS_TARGET_P is true if operand 0 is a target; it is false if the +diff --git a/gcc/config/loongarch/loongarch-modes.def b/gcc/config/loongarch/loongarch-modes.def +index 7f06e2d65..b69ad3d83 100644 +--- a/gcc/config/loongarch/loongarch-modes.def ++++ b/gcc/config/loongarch/loongarch-modes.def +@@ -23,3 +23,41 @@ FLOAT_MODE (TF, 16, ieee_quad_format); + + /* For floating point conditions in FCC registers. */ + CC_MODE (FCC); ++ ++/* Vector modes. */ ++VECTOR_MODES (INT, 4); /* V4QI V2HI */ ++VECTOR_MODES (INT, 8); /* V8QI V4HI V2SI */ ++VECTOR_MODES (FLOAT, 8); /* V4HF V2SF */ ++ ++/* For LARCH LSX 128 bits. */ ++VECTOR_MODES (INT, 16); /* V16QI V8HI V4SI V2DI */ ++VECTOR_MODES (FLOAT, 16); /* V4SF V2DF */ ++ ++VECTOR_MODES (INT, 32); /* V32QI V16HI V8SI V4DI */ ++VECTOR_MODES (FLOAT, 32); /* V8SF V4DF */ ++ ++/* Double-sized vector modes for vec_concat. */ ++/* VECTOR_MODE (INT, QI, 32); V32QI */ ++/* VECTOR_MODE (INT, HI, 16); V16HI */ ++/* VECTOR_MODE (INT, SI, 8); V8SI */ ++/* VECTOR_MODE (INT, DI, 4); V4DI */ ++/* VECTOR_MODE (FLOAT, SF, 8); V8SF */ ++/* VECTOR_MODE (FLOAT, DF, 4); V4DF */ ++ ++VECTOR_MODE (INT, QI, 64); /* V64QI */ ++VECTOR_MODE (INT, HI, 32); /* V32HI */ ++VECTOR_MODE (INT, SI, 16); /* V16SI */ ++VECTOR_MODE (INT, DI, 8); /* V8DI */ ++VECTOR_MODE (FLOAT, SF, 16); /* V16SF */ ++VECTOR_MODE (FLOAT, DF, 8); /* V8DF */ ++ ++VECTOR_MODES (FRACT, 4); /* V4QQ V2HQ */ ++VECTOR_MODES (UFRACT, 4); /* V4UQQ V2UHQ */ ++VECTOR_MODES (ACCUM, 4); /* V2HA */ ++VECTOR_MODES (UACCUM, 4); /* V2UHA */ ++ ++INT_MODE (OI, 32); ++ ++/* Keep the OI modes from confusing the compiler into thinking ++ that these modes could actually be used for computation. They are ++ only holders for vectors during data movement. */ +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 3ac3b5e19..24e42fa99 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -85,10 +85,18 @@ extern bool loongarch_split_move_p (rtx, rtx); + extern void loongarch_split_move (rtx, rtx, rtx); + extern bool loongarch_addu16i_imm12_operand_p (HOST_WIDE_INT, machine_mode); + extern void loongarch_split_plus_constant (rtx *, machine_mode); ++extern bool loongarch_split_move_insn_p (rtx, rtx); ++extern void loongarch_split_move_insn (rtx, rtx, rtx); ++extern void loongarch_split_128bit_move (rtx, rtx); ++extern bool loongarch_split_128bit_move_p (rtx, rtx); ++extern void loongarch_split_lsx_copy_d (rtx, rtx, rtx, rtx (*)(rtx, rtx, rtx)); ++extern void loongarch_split_lsx_insert_d (rtx, rtx, rtx, rtx); ++extern void loongarch_split_lsx_fill_d (rtx, rtx); + extern const char *loongarch_output_move (rtx, rtx); + extern bool loongarch_cfun_has_cprestore_slot_p (void); + #ifdef RTX_CODE + extern void loongarch_expand_scc (rtx *); ++extern bool loongarch_expand_vec_cmp (rtx *); + extern void loongarch_expand_conditional_branch (rtx *); + extern void loongarch_expand_conditional_move (rtx *); + extern void loongarch_expand_conditional_trap (rtx); +@@ -110,6 +118,15 @@ extern bool loongarch_small_data_pattern_p (rtx); + extern rtx loongarch_rewrite_small_data (rtx); + extern rtx loongarch_return_addr (int, rtx); + ++extern bool loongarch_const_vector_same_val_p (rtx, machine_mode); ++extern bool loongarch_const_vector_same_bytes_p (rtx, machine_mode); ++extern bool loongarch_const_vector_same_int_p (rtx, machine_mode, HOST_WIDE_INT, ++ HOST_WIDE_INT); ++extern bool loongarch_const_vector_shuffle_set_p (rtx, machine_mode); ++extern bool loongarch_const_vector_bitimm_set_p (rtx, machine_mode); ++extern bool loongarch_const_vector_bitimm_clr_p (rtx, machine_mode); ++extern rtx loongarch_lsx_vec_parallel_const_half (machine_mode, bool); ++extern rtx loongarch_gen_const_int_vector (machine_mode, HOST_WIDE_INT); + extern enum reg_class loongarch_secondary_reload_class (enum reg_class, + machine_mode, + rtx, bool); +@@ -129,6 +146,7 @@ extern const char *loongarch_output_equal_conditional_branch (rtx_insn *, + rtx *, + bool); + extern const char *loongarch_output_division (const char *, rtx *); ++extern const char *loongarch_lsx_output_division (const char *, rtx *); + extern const char *loongarch_output_probe_stack_range (rtx, rtx, rtx); + extern bool loongarch_hard_regno_rename_ok (unsigned int, unsigned int); + extern int loongarch_dspalu_bypass_p (rtx, rtx); +@@ -156,6 +174,13 @@ union loongarch_gen_fn_ptrs + extern void loongarch_expand_atomic_qihi (union loongarch_gen_fn_ptrs, + rtx, rtx, rtx, rtx, rtx); + ++extern void loongarch_expand_vector_init (rtx, rtx); ++extern void loongarch_expand_vec_unpack (rtx op2, bool, bool); ++extern void loongarch_expand_vec_perm (rtx, rtx, rtx, rtx); ++extern void loongarch_expand_vector_extract (rtx, rtx, int); ++extern void loongarch_expand_vector_reduc (rtx (*)(rtx, rtx, rtx), rtx, rtx); ++ ++extern int loongarch_ldst_scaled_shift (machine_mode); + extern bool loongarch_signed_immediate_p (unsigned HOST_WIDE_INT, int, int); + extern bool loongarch_unsigned_immediate_p (unsigned HOST_WIDE_INT, int, int); + extern bool loongarch_12bit_offset_address_p (rtx, machine_mode); +@@ -171,6 +196,9 @@ extern bool loongarch_split_symbol_type (enum loongarch_symbol_type); + typedef rtx (*mulsidi3_gen_fn) (rtx, rtx, rtx); + + extern void loongarch_register_frame_header_opt (void); ++extern void loongarch_expand_vec_cond_expr (machine_mode, machine_mode, rtx *); ++extern void loongarch_expand_vec_cond_mask_expr (machine_mode, machine_mode, ++ rtx *); + + /* Routines implemented in loongarch-c.c. */ + void loongarch_cpu_cpp_builtins (cpp_reader *); +@@ -180,6 +208,9 @@ extern void loongarch_atomic_assign_expand_fenv (tree *, tree *, tree *); + extern tree loongarch_builtin_decl (unsigned int, bool); + extern rtx loongarch_expand_builtin (tree, rtx, rtx subtarget ATTRIBUTE_UNUSED, + machine_mode, int); ++extern tree loongarch_builtin_vectorized_function (unsigned int, tree, tree); ++extern rtx loongarch_gen_const_int_vector_shuffle (machine_mode, int); + extern tree loongarch_build_builtin_va_list (void); + ++extern rtx loongarch_build_signbit_mask (machine_mode, bool, bool); + #endif /* ! GCC_LOONGARCH_PROTOS_H */ +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index bd774d4a9..40b83d72b 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -432,7 +432,7 @@ loongarch_flatten_aggregate_argument (const_tree type, + + static unsigned + loongarch_pass_aggregate_num_fpr (const_tree type, +- loongarch_aggregate_field fields2) ++ loongarch_aggregate_field fields2) + { + int n = loongarch_flatten_aggregate_argument (type, fields); + +@@ -770,7 +770,7 @@ loongarch_setup_incoming_varargs (cumulative_args_t cum, + { + rtx ptr = plus_constant (Pmode, virtual_incoming_args_rtx, + REG_PARM_STACK_SPACE (cfun->decl) +- - gp_saved * UNITS_PER_WORD); ++ - gp_saved * UNITS_PER_WORD); + rtx mem = gen_frame_mem (BLKmode, ptr); + set_mem_alias_set (mem, get_varargs_alias_set ()); + +@@ -1046,7 +1046,7 @@ rtx + loongarch_emit_move (rtx dest, rtx src) + { + return (can_create_pseudo_p () ? emit_move_insn (dest, src) +- : emit_move_insn_1 (dest, src)); ++ : emit_move_insn_1 (dest, src)); + } + + /* Save register REG to MEM. Make the instruction frame-related. */ +@@ -1674,6 +1674,140 @@ loongarch_symbol_binds_local_p (const_rtx x) + return false; + } + ++/* Return true if OP is a constant vector with the number of units in MODE, ++ and each unit has the same bit set. */ ++ ++bool ++loongarch_const_vector_bitimm_set_p (rtx op, machine_mode mode) ++{ ++ if (GET_CODE (op) == CONST_VECTOR && op != CONST0_RTX (mode)) ++ { ++ unsigned HOST_WIDE_INT val = UINTVAL (CONST_VECTOR_ELT (op, 0)); ++ int vlog2 = exact_log2 (val & GET_MODE_MASK (GET_MODE_INNER (mode))); ++ ++ if (vlog2 != -1) ++ { ++ gcc_assert (GET_MODE_CLASS (mode) == MODE_VECTOR_INT); ++ gcc_assert (vlog2 >= 0 && vlog2 <= GET_MODE_UNIT_BITSIZE (mode) - 1); ++ return loongarch_const_vector_same_val_p (op, mode); ++ } ++ } ++ ++ return false; ++} ++ ++/* Return true if OP is a constant vector with the number of units in MODE, ++ and each unit has the same bit clear. */ ++ ++bool ++loongarch_const_vector_bitimm_clr_p (rtx op, machine_mode mode) ++{ ++ if (GET_CODE (op) == CONST_VECTOR && op != CONSTM1_RTX (mode)) ++ { ++ unsigned HOST_WIDE_INT val = ~UINTVAL (CONST_VECTOR_ELT (op, 0)); ++ int vlog2 = exact_log2 (val & GET_MODE_MASK (GET_MODE_INNER (mode))); ++ ++ if (vlog2 != -1) ++ { ++ gcc_assert (GET_MODE_CLASS (mode) == MODE_VECTOR_INT); ++ gcc_assert (vlog2 >= 0 && vlog2 <= GET_MODE_UNIT_BITSIZE (mode) - 1); ++ return loongarch_const_vector_same_val_p (op, mode); ++ } ++ } ++ ++ return false; ++} ++ ++/* Return true if OP is a constant vector with the number of units in MODE, ++ and each unit has the same value. */ ++ ++bool ++loongarch_const_vector_same_val_p (rtx op, machine_mode mode) ++{ ++ int i, nunits = GET_MODE_NUNITS (mode); ++ rtx first; ++ ++ if (GET_CODE (op) != CONST_VECTOR || GET_MODE (op) != mode) ++ return false; ++ ++ first = CONST_VECTOR_ELT (op, 0); ++ for (i = 1; i < nunits; i++) ++ if (!rtx_equal_p (first, CONST_VECTOR_ELT (op, i))) ++ return false; ++ ++ return true; ++} ++ ++/* Return true if OP is a constant vector with the number of units in MODE, ++ and each unit has the same value as well as replicated bytes in the value. ++*/ ++ ++bool ++loongarch_const_vector_same_bytes_p (rtx op, machine_mode mode) ++{ ++ int i, bytes; ++ HOST_WIDE_INT val, first_byte; ++ rtx first; ++ ++ if (!loongarch_const_vector_same_val_p (op, mode)) ++ return false; ++ ++ first = CONST_VECTOR_ELT (op, 0); ++ bytes = GET_MODE_UNIT_SIZE (mode); ++ val = INTVAL (first); ++ first_byte = val & 0xff; ++ for (i = 1; i < bytes; i++) ++ { ++ val >>= 8; ++ if ((val & 0xff) != first_byte) ++ return false; ++ } ++ ++ return true; ++} ++ ++/* Return true if OP is a constant vector with the number of units in MODE, ++ and each unit has the same integer value in the range LOW, HIGH. */ ++ ++bool ++loongarch_const_vector_same_int_p (rtx op, machine_mode mode, HOST_WIDE_INT low, ++ HOST_WIDE_INT high) ++{ ++ HOST_WIDE_INT value; ++ rtx elem0; ++ ++ if (!loongarch_const_vector_same_val_p (op, mode)) ++ return false; ++ ++ elem0 = CONST_VECTOR_ELT (op, 0); ++ if (!CONST_INT_P (elem0)) ++ return false; ++ ++ value = INTVAL (elem0); ++ return (value >= low && value <= high); ++} ++ ++/* Return true if OP is a constant vector with repeated 4-element sets ++ in mode MODE. */ ++ ++bool ++loongarch_const_vector_shuffle_set_p (rtx op, machine_mode mode) ++{ ++ int nunits = GET_MODE_NUNITS (mode); ++ int nsets = nunits / 4; ++ int set = 0; ++ int i, j; ++ ++ /* Check if we have the same 4-element sets. */ ++ for (j = 0; j < nsets; j++, set = 4 * j) ++ for (i = 0; i < 4; i++) ++ if ((INTVAL (XVECEXP (op, 0, i)) ++ != (INTVAL (XVECEXP (op, 0, set + i)) - set)) ++ || !IN_RANGE (INTVAL (XVECEXP (op, 0, set + i)), 0, set + 3)) ++ return false; ++ return true; ++} ++ + /* Return true if rtx constants of mode MODE should be put into a small + data section. */ + +@@ -1791,6 +1925,11 @@ loongarch_symbolic_constant_p (rtx x, enum loongarch_symbol_type *symbol_type) + static int + loongarch_symbol_insns (enum loongarch_symbol_type type, machine_mode mode) + { ++ /* LSX LD.* and ST.* cannot support loading symbols via an immediate ++ operand. */ ++ if (LSX_SUPPORTED_MODE_P (mode)) ++ return 0; ++ + switch (type) + { + case SYMBOL_GOT_DISP: +@@ -1837,7 +1976,8 @@ loongarch_cannot_force_const_mem (machine_mode mode, rtx x) + references, reload will consider forcing C into memory and using + one of the instruction's memory alternatives. Returning false + here will force it to use an input reload instead. */ +- if (CONST_INT_P (x) && loongarch_legitimate_constant_p (mode, x)) ++ if ((CONST_INT_P (x) || GET_CODE (x) == CONST_VECTOR) ++ && loongarch_legitimate_constant_p (mode, x)) + return true; + + split_const (x, &base, &offset); +@@ -1914,6 +2054,12 @@ loongarch_valid_offset_p (rtx x, machine_mode mode) + && !IMM12_OPERAND (INTVAL (x) + GET_MODE_SIZE (mode) - UNITS_PER_WORD)) + return false; + ++ /* LSX LD.* and ST.* supports 10-bit signed offsets. */ ++ if (LSX_SUPPORTED_MODE_P (mode) ++ && !loongarch_signed_immediate_p (INTVAL (x), 10, ++ loongarch_ldst_scaled_shift (mode))) ++ return false; ++ + return true; + } + +@@ -1998,7 +2144,7 @@ loongarch_valid_lo_sum_p (enum loongarch_symbol_type symbol_type, + + static bool + loongarch_valid_index_p (struct loongarch_address_info *info, rtx x, +- machine_mode mode, bool strict_p) ++ machine_mode mode, bool strict_p) + { + rtx index; + +@@ -2051,7 +2197,7 @@ loongarch_classify_address (struct loongarch_address_info *info, rtx x, + } + + if (loongarch_valid_base_register_p (XEXP (x, 1), mode, strict_p) +- && loongarch_valid_index_p (info, XEXP (x, 0), mode, strict_p)) ++ && loongarch_valid_index_p (info, XEXP (x, 0), mode, strict_p)) + { + info->reg = XEXP (x, 1); + return true; +@@ -2126,6 +2272,7 @@ loongarch_address_insns (rtx x, machine_mode mode, bool might_split_p) + { + struct loongarch_address_info addr; + int factor; ++ bool lsx_p = !might_split_p && LSX_SUPPORTED_MODE_P (mode); + + if (!loongarch_classify_address (&addr, x, mode, false)) + return 0; +@@ -2143,15 +2290,29 @@ loongarch_address_insns (rtx x, machine_mode mode, bool might_split_p) + switch (addr.type) + { + case ADDRESS_REG: ++ if (lsx_p) ++ { ++ /* LSX LD.* and ST.* supports 10-bit signed offsets. */ ++ if (loongarch_signed_immediate_p (INTVAL (addr.offset), 10, ++ loongarch_ldst_scaled_shift (mode))) ++ return 1; ++ else ++ return 0; ++ } ++ return factor; ++ + case ADDRESS_REG_REG: +- case ADDRESS_CONST_INT: + return factor; + ++ case ADDRESS_CONST_INT: ++ return lsx_p ? 0 : factor; ++ + case ADDRESS_LO_SUM: + return factor + 1; + + case ADDRESS_SYMBOLIC: +- return factor * loongarch_symbol_insns (addr.symbol_type, mode); ++ return lsx_p ? 0 ++ : factor * loongarch_symbol_insns (addr.symbol_type, mode); + } + return 0; + } +@@ -2177,6 +2338,19 @@ loongarch_signed_immediate_p (unsigned HOST_WIDE_INT x, int bits, + return loongarch_unsigned_immediate_p (x, bits, shift); + } + ++/* Return the scale shift that applied to LSX LD/ST address offset. */ ++ ++int ++loongarch_ldst_scaled_shift (machine_mode mode) ++{ ++ int shift = exact_log2 (GET_MODE_UNIT_SIZE (mode)); ++ ++ if (shift < 0 || shift > 8) ++ gcc_unreachable (); ++ ++ return shift; ++} ++ + /* Return true if X is a legitimate address with a 12-bit offset + or addr.type is ADDRESS_LO_SUM. + MODE is the mode of the value being accessed. */ +@@ -2244,6 +2418,9 @@ loongarch_const_insns (rtx x) + return loongarch_integer_cost (INTVAL (x)); + + case CONST_VECTOR: ++ if (LSX_SUPPORTED_MODE_P (GET_MODE (x)) ++ && loongarch_const_vector_same_int_p (x, GET_MODE (x), -512, 511)) ++ return 1; + /* Fall through. */ + case CONST_DOUBLE: + return x == CONST0_RTX (GET_MODE (x)) ? 1 : 0; +@@ -2278,7 +2455,7 @@ loongarch_const_insns (rtx x) + case SYMBOL_REF: + case LABEL_REF: + return loongarch_symbol_insns ( +- loongarch_classify_symbol (x), MAX_MACHINE_MODE); ++ loongarch_classify_symbol (x), MAX_MACHINE_MODE); + + default: + return 0; +@@ -2300,7 +2477,26 @@ loongarch_split_const_insns (rtx x) + return low + high; + } + +-static bool loongarch_split_move_insn_p (rtx dest, rtx src); ++bool loongarch_split_move_insn_p (rtx dest, rtx src); ++/* Return one word of 128-bit value OP, taking into account the fixed ++ endianness of certain registers. BYTE selects from the byte address. */ ++ ++rtx ++loongarch_subword_at_byte (rtx op, unsigned int byte) ++{ ++ machine_mode mode; ++ ++ mode = GET_MODE (op); ++ if (mode == VOIDmode) ++ mode = TImode; ++ ++ gcc_assert (!FP_REG_RTX_P (op)); ++ ++ if (MEM_P (op)) ++ return loongarch_rewrite_small_data (adjust_address (op, word_mode, byte)); ++ ++ return simplify_gen_subreg (word_mode, op, mode, byte); ++} + + /* Return the number of instructions needed to implement INSN, + given that it loads from or stores to MEM. */ +@@ -3061,9 +3257,10 @@ loongarch_legitimize_move (machine_mode mode, rtx dest, rtx src) + + /* Both src and dest are non-registers; one special case is supported where + the source is (const_int 0) and the store can source the zero register. +- */ ++ LSX is never able to source the zero register directly in ++ memory operations. */ + if (!register_operand (dest, mode) && !register_operand (src, mode) +- && !const_0_operand (src, mode)) ++ && (!const_0_operand (src, mode) || LSX_SUPPORTED_MODE_P (mode))) + { + loongarch_emit_move (dest, force_reg (mode, src)); + return true; +@@ -3635,6 +3832,54 @@ loongarch_rtx_costs (rtx x, machine_mode mode, int outer_code, + } + } + ++/* Vectorizer cost model implementation. */ ++ ++/* Implement targetm.vectorize.builtin_vectorization_cost. */ ++ ++static int ++loongarch_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost, ++ tree vectype, ++ int misalign ATTRIBUTE_UNUSED) ++{ ++ unsigned elements; ++ ++ switch (type_of_cost) ++ { ++ case scalar_stmt: ++ case scalar_load: ++ case vector_stmt: ++ case vector_load: ++ case vec_to_scalar: ++ case scalar_to_vec: ++ case cond_branch_not_taken: ++ case vec_promote_demote: ++ case scalar_store: ++ case vector_store: ++ return 1; ++ ++ case vec_perm: ++ return 1; ++ ++ case unaligned_load: ++ case vector_gather_load: ++ return 2; ++ ++ case unaligned_store: ++ case vector_scatter_store: ++ return 10; ++ ++ case cond_branch_taken: ++ return 3; ++ ++ case vec_construct: ++ elements = TYPE_VECTOR_SUBPARTS (vectype); ++ return elements / 2 + 1; ++ ++ default: ++ gcc_unreachable (); ++ } ++} ++ + /* Implement TARGET_ADDRESS_COST. */ + + static int +@@ -3689,6 +3934,11 @@ loongarch_split_move_p (rtx dest, rtx src) + if (FP_REG_RTX_P (src) && MEM_P (dest)) + return false; + } ++ ++ /* Check if LSX moves need splitting. */ ++ if (LSX_SUPPORTED_MODE_P (GET_MODE (dest))) ++ return loongarch_split_128bit_move_p (dest, src); ++ + /* Otherwise split all multiword moves. */ + return size > UNITS_PER_WORD; + } +@@ -3702,7 +3952,9 @@ loongarch_split_move (rtx dest, rtx src, rtx insn_) + rtx low_dest; + + gcc_checking_assert (loongarch_split_move_p (dest, src)); +- if (FP_REG_RTX_P (dest) || FP_REG_RTX_P (src)) ++ if (LSX_SUPPORTED_MODE_P (GET_MODE (dest))) ++ loongarch_split_128bit_move (dest, src); ++ else if (FP_REG_RTX_P (dest) || FP_REG_RTX_P (src)) + { + if (!TARGET_64BIT && GET_MODE (dest) == DImode) + emit_insn (gen_move_doubleword_fprdi (dest, src)); +@@ -3806,12 +4058,21 @@ loongarch_split_plus_constant (rtx *op, machine_mode mode) + + /* Return true if a move from SRC to DEST in INSN should be split. */ + +-static bool ++bool + loongarch_split_move_insn_p (rtx dest, rtx src) + { + return loongarch_split_move_p (dest, src); + } + ++/* Split a move from SRC to DEST in INSN, given that ++ loongarch_split_move_insn_p holds. */ ++ ++void ++loongarch_split_move_insn (rtx dest, rtx src, rtx insn) ++{ ++ loongarch_split_move (dest, src, insn); ++} ++ + /* Implement TARGET_CONSTANT_ALIGNMENT. */ + + static HOST_WIDE_INT +@@ -3858,7 +4119,7 @@ const char * + loongarch_output_move_index_float (rtx x, machine_mode mode, bool ldr) + { + int index = exact_log2 (GET_MODE_SIZE (mode)); +- if (!IN_RANGE (index, 2, 3)) ++ if (!IN_RANGE (index, 2, 4)) + return NULL; + + struct loongarch_address_info info; +@@ -3867,20 +4128,216 @@ loongarch_output_move_index_float (rtx x, machine_mode mode, bool ldr) + || !loongarch_legitimate_address_p (mode, x, false)) + return NULL; + +- const char *const insn2 = ++ const char *const insn3 = + { + { + "fstx.s\t%1,%0", +- "fstx.d\t%1,%0" ++ "fstx.d\t%1,%0", ++ "vstx\t%w1,%0" + }, + { + "fldx.s\t%0,%1", +- "fldx.d\t%0,%1" +- }, ++ "fldx.d\t%0,%1", ++ "vldx\t%w0,%1" ++ } + }; + + return insnldrindex-2; + } ++/* Return true if a 128-bit move from SRC to DEST should be split. */ ++ ++bool ++loongarch_split_128bit_move_p (rtx dest, rtx src) ++{ ++ /* LSX-to-LSX moves can be done in a single instruction. */ ++ if (FP_REG_RTX_P (src) && FP_REG_RTX_P (dest)) ++ return false; ++ ++ /* Check for LSX loads and stores. */ ++ if (FP_REG_RTX_P (dest) && MEM_P (src)) ++ return false; ++ if (FP_REG_RTX_P (src) && MEM_P (dest)) ++ return false; ++ ++ /* Check for LSX set to an immediate const vector with valid replicated ++ element. */ ++ if (FP_REG_RTX_P (dest) ++ && loongarch_const_vector_same_int_p (src, GET_MODE (src), -512, 511)) ++ return false; ++ ++ /* Check for LSX load zero immediate. */ ++ if (FP_REG_RTX_P (dest) && src == CONST0_RTX (GET_MODE (src))) ++ return false; ++ ++ return true; ++} ++ ++/* Split a 128-bit move from SRC to DEST. */ ++ ++void ++loongarch_split_128bit_move (rtx dest, rtx src) ++{ ++ int byte, index; ++ rtx low_dest, low_src, d, s; ++ ++ if (FP_REG_RTX_P (dest)) ++ { ++ gcc_assert (!MEM_P (src)); ++ ++ rtx new_dest = dest; ++ if (!TARGET_64BIT) ++ { ++ if (GET_MODE (dest) != V4SImode) ++ new_dest = simplify_gen_subreg (V4SImode, dest, GET_MODE (dest), 0); ++ } ++ else ++ { ++ if (GET_MODE (dest) != V2DImode) ++ new_dest = simplify_gen_subreg (V2DImode, dest, GET_MODE (dest), 0); ++ } ++ ++ for (byte = 0, index = 0; byte < GET_MODE_SIZE (TImode); ++ byte += UNITS_PER_WORD, index++) ++ { ++ s = loongarch_subword_at_byte (src, byte); ++ if (!TARGET_64BIT) ++ emit_insn (gen_lsx_vinsgr2vr_w (new_dest, s, new_dest, ++ GEN_INT (1 << index))); ++ else ++ emit_insn (gen_lsx_vinsgr2vr_d (new_dest, s, new_dest, ++ GEN_INT (1 << index))); ++ } ++ } ++ else if (FP_REG_RTX_P (src)) ++ { ++ gcc_assert (!MEM_P (dest)); ++ ++ rtx new_src = src; ++ if (!TARGET_64BIT) ++ { ++ if (GET_MODE (src) != V4SImode) ++ new_src = simplify_gen_subreg (V4SImode, src, GET_MODE (src), 0); ++ } ++ else ++ { ++ if (GET_MODE (src) != V2DImode) ++ new_src = simplify_gen_subreg (V2DImode, src, GET_MODE (src), 0); ++ } ++ ++ for (byte = 0, index = 0; byte < GET_MODE_SIZE (TImode); ++ byte += UNITS_PER_WORD, index++) ++ { ++ d = loongarch_subword_at_byte (dest, byte); ++ if (!TARGET_64BIT) ++ emit_insn (gen_lsx_vpickve2gr_w (d, new_src, GEN_INT (index))); ++ else ++ emit_insn (gen_lsx_vpickve2gr_d (d, new_src, GEN_INT (index))); ++ } ++ } ++ else ++ { ++ low_dest = loongarch_subword_at_byte (dest, 0); ++ low_src = loongarch_subword_at_byte (src, 0); ++ gcc_assert (REG_P (low_dest) && REG_P (low_src)); ++ /* Make sure the source register is not written before reading. */ ++ if (REGNO (low_dest) <= REGNO (low_src)) ++ { ++ for (byte = 0; byte < GET_MODE_SIZE (TImode); ++ byte += UNITS_PER_WORD) ++ { ++ d = loongarch_subword_at_byte (dest, byte); ++ s = loongarch_subword_at_byte (src, byte); ++ loongarch_emit_move (d, s); ++ } ++ } ++ else ++ { ++ for (byte = GET_MODE_SIZE (TImode) - UNITS_PER_WORD; byte >= 0; ++ byte -= UNITS_PER_WORD) ++ { ++ d = loongarch_subword_at_byte (dest, byte); ++ s = loongarch_subword_at_byte (src, byte); ++ loongarch_emit_move (d, s); ++ } ++ } ++ } ++} ++ ++ ++/* Split a COPY_S.D with operands DEST, SRC and INDEX. GEN is a function ++ used to generate subregs. */ ++ ++void ++loongarch_split_lsx_copy_d (rtx dest, rtx src, rtx index, ++ rtx (*gen_fn)(rtx, rtx, rtx)) ++{ ++ gcc_assert ((GET_MODE (src) == V2DImode && GET_MODE (dest) == DImode) ++ || (GET_MODE (src) == V2DFmode && GET_MODE (dest) == DFmode)); ++ ++ /* Note that low is always from the lower index, and high is always ++ from the higher index. */ ++ rtx low = loongarch_subword (dest, false); ++ rtx high = loongarch_subword (dest, true); ++ rtx new_src = simplify_gen_subreg (V4SImode, src, GET_MODE (src), 0); ++ ++ emit_insn (gen_fn (low, new_src, GEN_INT (INTVAL (index) * 2))); ++ emit_insn (gen_fn (high, new_src, GEN_INT (INTVAL (index) * 2 + 1))); ++} ++ ++/* Split a INSERT.D with operand DEST, SRC1.INDEX and SRC2. */ ++ ++void ++loongarch_split_lsx_insert_d (rtx dest, rtx src1, rtx index, rtx src2) ++{ ++ int i; ++ gcc_assert (GET_MODE (dest) == GET_MODE (src1)); ++ gcc_assert ((GET_MODE (dest) == V2DImode ++ && (GET_MODE (src2) == DImode || src2 == const0_rtx)) ++ || (GET_MODE (dest) == V2DFmode && GET_MODE (src2) == DFmode)); ++ ++ /* Note that low is always from the lower index, and high is always ++ from the higher index. */ ++ rtx low = loongarch_subword (src2, false); ++ rtx high = loongarch_subword (src2, true); ++ rtx new_dest = simplify_gen_subreg (V4SImode, dest, GET_MODE (dest), 0); ++ rtx new_src1 = simplify_gen_subreg (V4SImode, src1, GET_MODE (src1), 0); ++ i = exact_log2 (INTVAL (index)); ++ gcc_assert (i != -1); ++ ++ emit_insn (gen_lsx_vinsgr2vr_w (new_dest, low, new_src1, ++ GEN_INT (1 << (i * 2)))); ++ emit_insn (gen_lsx_vinsgr2vr_w (new_dest, high, new_dest, ++ GEN_INT (1 << (i * 2 + 1)))); ++} ++ ++/* Split FILL.D. */ ++ ++void ++loongarch_split_lsx_fill_d (rtx dest, rtx src) ++{ ++ gcc_assert ((GET_MODE (dest) == V2DImode ++ && (GET_MODE (src) == DImode || src == const0_rtx)) ++ || (GET_MODE (dest) == V2DFmode && GET_MODE (src) == DFmode)); ++ ++ /* Note that low is always from the lower index, and high is always ++ from the higher index. */ ++ rtx low, high; ++ if (src == const0_rtx) ++ { ++ low = src; ++ high = src; ++ } ++ else ++ { ++ low = loongarch_subword (src, false); ++ high = loongarch_subword (src, true); ++ } ++ rtx new_dest = simplify_gen_subreg (V4SImode, dest, GET_MODE (dest), 0); ++ emit_insn (gen_lsx_vreplgr2vr_w (new_dest, low)); ++ emit_insn (gen_lsx_vinsgr2vr_w (new_dest, high, new_dest, GEN_INT (1 << 1))); ++ emit_insn (gen_lsx_vinsgr2vr_w (new_dest, high, new_dest, GEN_INT (1 << 3))); ++} ++ + + /* Return the appropriate instructions to move SRC into DEST. Assume + that SRC is operand 1 and DEST is operand 0. */ +@@ -3892,10 +4349,25 @@ loongarch_output_move (rtx dest, rtx src) + enum rtx_code src_code = GET_CODE (src); + machine_mode mode = GET_MODE (dest); + bool dbl_p = (GET_MODE_SIZE (mode) == 8); ++ bool lsx_p = LSX_SUPPORTED_MODE_P (mode); + + if (loongarch_split_move_p (dest, src)) + return "#"; + ++ if ((lsx_p) ++ && dest_code == REG && FP_REG_P (REGNO (dest)) ++ && src_code == CONST_VECTOR ++ && CONST_INT_P (CONST_VECTOR_ELT (src, 0))) ++ { ++ gcc_assert (loongarch_const_vector_same_int_p (src, mode, -512, 511)); ++ switch (GET_MODE_SIZE (mode)) ++ { ++ case 16: ++ return "vrepli.%v0\t%w0,%E1"; ++ default: gcc_unreachable (); ++ } ++ } ++ + if ((src_code == REG && GP_REG_P (REGNO (src))) + || (src == CONST0_RTX (mode))) + { +@@ -3905,7 +4377,21 @@ loongarch_output_move (rtx dest, rtx src) + return "or\t%0,%z1,$r0"; + + if (FP_REG_P (REGNO (dest))) +- return dbl_p ? "movgr2fr.d\t%0,%z1" : "movgr2fr.w\t%0,%z1"; ++ { ++ if (lsx_p) ++ { ++ gcc_assert (src == CONST0_RTX (GET_MODE (src))); ++ switch (GET_MODE_SIZE (mode)) ++ { ++ case 16: ++ return "vrepli.b\t%w0,0"; ++ default: ++ gcc_unreachable (); ++ } ++ } ++ ++ return dbl_p ? "movgr2fr.d\t%0,%z1" : "movgr2fr.w\t%0,%z1"; ++ } + } + if (dest_code == MEM) + { +@@ -3947,7 +4433,10 @@ loongarch_output_move (rtx dest, rtx src) + { + if (src_code == REG) + if (FP_REG_P (REGNO (src))) +- return dbl_p ? "movfr2gr.d\t%0,%1" : "movfr2gr.s\t%0,%1"; ++ { ++ gcc_assert (!lsx_p); ++ return dbl_p ? "movfr2gr.d\t%0,%1" : "movfr2gr.s\t%0,%1"; ++ } + + if (src_code == MEM) + { +@@ -3992,7 +4481,7 @@ loongarch_output_move (rtx dest, rtx src) + enum loongarch_symbol_type type = SYMBOL_PCREL; + + if (UNSPEC_ADDRESS_P (x)) +- type = UNSPEC_ADDRESS_TYPE (x); ++ type = UNSPEC_ADDRESS_TYPE (x); + + if (type == SYMBOL_TLS_LE) + return "lu12i.w\t%0,%h1"; +@@ -4027,7 +4516,20 @@ loongarch_output_move (rtx dest, rtx src) + if (src_code == REG && FP_REG_P (REGNO (src))) + { + if (dest_code == REG && FP_REG_P (REGNO (dest))) +- return dbl_p ? "fmov.d\t%0,%1" : "fmov.s\t%0,%1"; ++ { ++ if (lsx_p) ++ { ++ switch (GET_MODE_SIZE (mode)) ++ { ++ case 16: ++ return "vori.b\t%w0,%w1,0"; ++ default: ++ gcc_unreachable (); ++ } ++ } ++ ++ return dbl_p ? "fmov.d\t%0,%1" : "fmov.s\t%0,%1"; ++ } + + if (dest_code == MEM) + { +@@ -4038,6 +4540,17 @@ loongarch_output_move (rtx dest, rtx src) + if (insn) + return insn; + ++ if (lsx_p) ++ { ++ switch (GET_MODE_SIZE (mode)) ++ { ++ case 16: ++ return "vst\t%w1,%0"; ++ default: ++ gcc_unreachable (); ++ } ++ } ++ + return dbl_p ? "fst.d\t%1,%0" : "fst.s\t%1,%0"; + } + } +@@ -4053,6 +4566,16 @@ loongarch_output_move (rtx dest, rtx src) + if (insn) + return insn; + ++ if (lsx_p) ++ { ++ switch (GET_MODE_SIZE (mode)) ++ { ++ case 16: ++ return "vld\t%w0,%1"; ++ default: ++ gcc_unreachable (); ++ } ++ } + return dbl_p ? "fld.d\t%0,%1" : "fld.s\t%0,%1"; + } + } +@@ -4252,6 +4775,7 @@ loongarch_extend_comparands (rtx_code code, rtx *op0, rtx *op1) + } + } + ++ + /* Convert a comparison into something that can be used in a branch. On + entry, *OP0 and *OP1 are the values being compared and *CODE is the code + used to compare them. Update them to describe the final comparison. */ +@@ -5056,9 +5580,12 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part, + + 'A' Print a _DB suffix if the memory model requires a release. + 'b' Print the address of a memory operand, without offset. ++ 'B' Print CONST_INT OP element 0 of a replicated CONST_VECTOR ++ as an unsigned byte 0..255. + 'c' Print an integer. + 'C' Print the integer branch condition for comparison OP. + 'd' Print CONST_INT OP in decimal. ++ 'E' Print CONST_INT OP element 0 of a replicated CONST_VECTOR in decimal. + 'F' Print the FPU branch condition for comparison OP. + 'G' Print a DBAR insn if the memory model requires a release. + 'H' Print address 52-61bit relocation associated with OP. +@@ -5074,13 +5601,16 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part, + 't' Like 'T', but with the EQ/NE cases reversed + 'V' Print exact log2 of CONST_INT OP element 0 of a replicated + CONST_VECTOR in decimal. ++ 'v' Print the insn size suffix b, h, w or d for vector modes V16QI, V8HI, ++ V4SI, V2SI, and w, d for vector modes V4SF, V2DF respectively. + 'W' Print the inverse of the FPU branch condition for comparison OP. ++ 'w' Print a LSX register. + 'X' Print CONST_INT OP in hexadecimal format. + 'x' Print the low 16 bits of CONST_INT OP in hexadecimal format. + 'Y' Print loongarch_fp_conditionsINTVAL (OP) + 'y' Print exact log2 of CONST_INT OP in decimal. + 'Z' Print OP and a comma for 8CC, otherwise print nothing. +- 'z' Print $0 if OP is zero, otherwise print OP normally. */ ++ 'z' Print $r0 if OP is zero, otherwise print OP normally. */ + + static void + loongarch_print_operand (FILE *file, rtx op, int letter) +@@ -5102,6 +5632,18 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + if (loongarch_memmodel_needs_rel_acq_fence ((enum memmodel) INTVAL (op))) + fputs ("_db", file); + break; ++ case 'E': ++ if (GET_CODE (op) == CONST_VECTOR) ++ { ++ gcc_assert (loongarch_const_vector_same_val_p (op, GET_MODE (op))); ++ op = CONST_VECTOR_ELT (op, 0); ++ gcc_assert (CONST_INT_P (op)); ++ fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (op)); ++ } ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ break; ++ + + case 'c': + if (CONST_INT_P (op)) +@@ -5152,6 +5694,18 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + loongarch_print_operand_reloc (file, op, false /* hi64_part*/, + false /* lo_reloc */); + break; ++ case 'B': ++ if (GET_CODE (op) == CONST_VECTOR) ++ { ++ gcc_assert (loongarch_const_vector_same_val_p (op, GET_MODE (op))); ++ op = CONST_VECTOR_ELT (op, 0); ++ gcc_assert (CONST_INT_P (op)); ++ unsigned HOST_WIDE_INT val8 = UINTVAL (op) & GET_MODE_MASK (QImode); ++ fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, val8); ++ } ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ break; + + case 'm': + if (CONST_INT_P (op)) +@@ -5198,10 +5752,45 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + output_operand_lossage ("invalid use of '%%%c'", letter); + break; + +- case 'W': +- loongarch_print_float_branch_condition (file, reverse_condition (code), +- letter); +- break; ++ case 'v': ++ switch (GET_MODE (op)) ++ { ++ case E_V16QImode: ++ case E_V32QImode: ++ fprintf (file, "b"); ++ break; ++ case E_V8HImode: ++ case E_V16HImode: ++ fprintf (file, "h"); ++ break; ++ case E_V4SImode: ++ case E_V4SFmode: ++ case E_V8SImode: ++ case E_V8SFmode: ++ fprintf (file, "w"); ++ break; ++ case E_V2DImode: ++ case E_V2DFmode: ++ case E_V4DImode: ++ case E_V4DFmode: ++ fprintf (file, "d"); ++ break; ++ default: ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ } ++ break; ++ ++ case 'W': ++ loongarch_print_float_branch_condition (file, reverse_condition (code), ++ letter); ++ break; ++ ++ case 'w': ++ if (code == REG && LSX_REG_P (REGNO (op))) ++ fprintf (file, "$vr%s", ®_namesREGNO (op)2); ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ break; + + case 'x': + if (CONST_INT_P (op)) +@@ -5574,9 +6163,13 @@ loongarch_hard_regno_mode_ok_uncached (unsigned int regno, machine_mode mode) + size = GET_MODE_SIZE (mode); + mclass = GET_MODE_CLASS (mode); + +- if (GP_REG_P (regno)) ++ if (GP_REG_P (regno) && !LSX_SUPPORTED_MODE_P (mode)) + return ((regno - GP_REG_FIRST) & 1) == 0 || size <= UNITS_PER_WORD; + ++ /* For LSX, allow TImode and 128-bit vector modes in all FPR. */ ++ if (FP_REG_P (regno) && LSX_SUPPORTED_MODE_P (mode)) ++ return true; ++ + if (FP_REG_P (regno)) + { + if (mclass == MODE_FLOAT +@@ -5603,6 +6196,17 @@ loongarch_hard_regno_mode_ok (unsigned int regno, machine_mode mode) + return loongarch_hard_regno_mode_ok_pmoderegno; + } + ++ ++static bool ++loongarch_hard_regno_call_part_clobbered (unsigned int, ++ unsigned int regno, machine_mode mode) ++{ ++ if (ISA_HAS_LSX && FP_REG_P (regno) && GET_MODE_SIZE (mode) > 8) ++ return true; ++ ++ return false; ++} ++ + /* Implement TARGET_HARD_REGNO_NREGS. */ + + static unsigned int +@@ -5614,7 +6218,12 @@ loongarch_hard_regno_nregs (unsigned int regno, machine_mode mode) + return (GET_MODE_SIZE (mode) + 3) / 4; + + if (FP_REG_P (regno)) +- return (GET_MODE_SIZE (mode) + UNITS_PER_FPREG - 1) / UNITS_PER_FPREG; ++ { ++ if (LSX_SUPPORTED_MODE_P (mode)) ++ return 1; ++ ++ return (GET_MODE_SIZE (mode) + UNITS_PER_FPREG - 1) / UNITS_PER_FPREG; ++ } + + /* All other registers are word-sized. */ + return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD; +@@ -5641,8 +6250,12 @@ loongarch_class_max_nregs (enum reg_class rclass, machine_mode mode) + if (hard_reg_set_intersect_p (left, reg_class_contents(int) FP_REGS)) + { + if (loongarch_hard_regno_mode_ok (FP_REG_FIRST, mode)) +- size = MIN (size, UNITS_PER_FPREG); +- ++ { ++ if (LSX_SUPPORTED_MODE_P (mode)) ++ size = MIN (size, UNITS_PER_LSX_REG); ++ else ++ size = MIN (size, UNITS_PER_FPREG); ++ } + left &= ~reg_class_contentsFP_REGS; + } + if (!hard_reg_set_empty_p (left)) +@@ -5653,9 +6266,13 @@ loongarch_class_max_nregs (enum reg_class rclass, machine_mode mode) + /* Implement TARGET_CAN_CHANGE_MODE_CLASS. */ + + static bool +-loongarch_can_change_mode_class (machine_mode, machine_mode, ++loongarch_can_change_mode_class (machine_mode from, machine_mode to, + reg_class_t rclass) + { ++ /* Allow conversions between different LSX vector modes. */ ++ if (LSX_SUPPORTED_MODE_P (from) && LSX_SUPPORTED_MODE_P (to)) ++ return true; ++ + return !reg_classes_intersect_p (FP_REGS, rclass); + } + +@@ -5675,7 +6292,7 @@ loongarch_mode_ok_for_mov_fmt_p (machine_mode mode) + return TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT; + + default: +- return 0; ++ return LSX_SUPPORTED_MODE_P (mode); + } + } + +@@ -5832,7 +6449,12 @@ loongarch_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x, + if (regno < 0 + || (MEM_P (x) + && (GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8))) +- /* In this case we can use fld.s, fst.s, fld.d or fst.d. */ ++ /* In this case we can use lwc1, swc1, ldc1 or sdc1. We'll use ++ pairs of lwc1s and swc1s if ldc1 and sdc1 are not supported. */ ++ return NO_REGS; ++ ++ if (MEM_P (x) && LSX_SUPPORTED_MODE_P (mode)) ++ /* In this case we can use LSX LD.* and ST.*. */ + return NO_REGS; + + if (GP_REG_P (regno) || x == CONST0_RTX (mode)) +@@ -5867,6 +6489,14 @@ loongarch_valid_pointer_mode (scalar_int_mode mode) + return mode == SImode || (TARGET_64BIT && mode == DImode); + } + ++/* Implement TARGET_VECTOR_MODE_SUPPORTED_P. */ ++ ++static bool ++loongarch_vector_mode_supported_p (machine_mode mode) ++{ ++ return LSX_SUPPORTED_MODE_P (mode); ++} ++ + /* Implement TARGET_SCALAR_MODE_SUPPORTED_P. */ + + static bool +@@ -5879,6 +6509,48 @@ loongarch_scalar_mode_supported_p (scalar_mode mode) + return default_scalar_mode_supported_p (mode); + } + ++/* Implement TARGET_VECTORIZE_PREFERRED_SIMD_MODE. */ ++ ++static machine_mode ++loongarch_preferred_simd_mode (scalar_mode mode) ++{ ++ if (!ISA_HAS_LSX) ++ return word_mode; ++ ++ switch (mode) ++ { ++ case E_QImode: ++ return E_V16QImode; ++ case E_HImode: ++ return E_V8HImode; ++ case E_SImode: ++ return E_V4SImode; ++ case E_DImode: ++ return E_V2DImode; ++ ++ case E_SFmode: ++ return E_V4SFmode; ++ ++ case E_DFmode: ++ return E_V2DFmode; ++ ++ default: ++ break; ++ } ++ return word_mode; ++} ++ ++static unsigned int ++loongarch_autovectorize_vector_modes (vector_modes *modes, bool) ++{ ++ if (ISA_HAS_LSX) ++ { ++ modes->safe_push (V16QImode); ++ } ++ ++ return 0; ++} ++ + /* Return the assembly code for INSN, which has the operands given by + OPERANDS, and which branches to OPERANDS0 if some condition is true. + BRANCH_IF_TRUE is the asm template that should be used if OPERANDS0 +@@ -6043,6 +6715,29 @@ loongarch_output_division (const char *division, rtx *operands) + return s; + } + ++/* Return the assembly code for LSX DIV_{S,U}.DF or MOD_{S,U}.DF instructions, ++ which has the operands given by OPERANDS. Add in a divide-by-zero check ++ if needed. */ ++ ++const char * ++loongarch_lsx_output_division (const char *division, rtx *operands) ++{ ++ const char *s; ++ ++ s = division; ++ if (TARGET_CHECK_ZERO_DIV) ++ { ++ if (ISA_HAS_LSX) ++ { ++ output_asm_insn ("vsetallnez.%v0\t$fcc7,%w2",operands); ++ output_asm_insn (s, operands); ++ output_asm_insn ("bcnez\t$fcc7,1f", operands); ++ } ++ s = "break\t7\n1:"; ++ } ++ return s; ++} ++ + /* Implement TARGET_SCHED_ADJUST_COST. We assume that anti and output + dependencies have no cost. */ + +@@ -6323,6 +7018,9 @@ loongarch_option_override_internal (struct gcc_options *opts, + if (TARGET_DIRECT_EXTERN_ACCESS && flag_shlib) + error ("%qs cannot be used for compiling a shared library", + "-mdirect-extern-access"); ++ if (loongarch_vector_access_cost == 0) ++ loongarch_vector_access_cost = 5; ++ + + switch (la_target.cmodel) + { +@@ -6541,64 +7239,60 @@ loongarch_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value) + emit_insn (gen_clear_cache (addr, end_addr)); + } + +-/* Implement HARD_REGNO_CALLER_SAVE_MODE. */ +- +-machine_mode +-loongarch_hard_regno_caller_save_mode (unsigned int regno, unsigned int nregs, +- machine_mode mode) +-{ +- /* For performance, avoid saving/restoring upper parts of a register +- by returning MODE as save mode when the mode is known. */ +- if (mode == VOIDmode) +- return choose_hard_reg_mode (regno, nregs, NULL); +- else +- return mode; +-} ++/* Generate or test for an insn that supports a constant permutation. */ + +-/* Implement TARGET_SPILL_CLASS. */ ++#define MAX_VECT_LEN 32 + +-static reg_class_t +-loongarch_spill_class (reg_class_t rclass ATTRIBUTE_UNUSED, +- machine_mode mode ATTRIBUTE_UNUSED) ++struct expand_vec_perm_d + { +- return NO_REGS; +-} +- +-/* Implement TARGET_PROMOTE_FUNCTION_MODE. */ ++ rtx target, op0, op1; ++ unsigned char permMAX_VECT_LEN; ++ machine_mode vmode; ++ unsigned char nelt; ++ bool one_vector_p; ++ bool testing_p; ++}; + +-/* This function is equivalent to default_promote_function_mode_always_promote +- except that it returns a promoted mode even if type is NULL_TREE. This is +- needed by libcalls which have no type (only a mode) such as fixed conversion +- routines that take a signed or unsigned char/short argument and convert it +- to a fixed type. */ ++/* Construct (set target (vec_select op0 (parallel perm))) and ++ return true if that's a valid instruction in the active ISA. */ + +-static machine_mode +-loongarch_promote_function_mode (const_tree type ATTRIBUTE_UNUSED, +- machine_mode mode, +- int *punsignedp ATTRIBUTE_UNUSED, +- const_tree fntype ATTRIBUTE_UNUSED, +- int for_return ATTRIBUTE_UNUSED) ++static bool ++loongarch_expand_vselect (rtx target, rtx op0, ++ const unsigned char *perm, unsigned nelt) + { +- int unsignedp; ++ rtx rpermMAX_VECT_LEN, x; ++ rtx_insn *insn; ++ unsigned i; + +- if (type != NULL_TREE) +- return promote_mode (type, mode, punsignedp); ++ for (i = 0; i < nelt; ++i) ++ rpermi = GEN_INT (permi); + +- unsignedp = *punsignedp; +- PROMOTE_MODE (mode, unsignedp, type); +- *punsignedp = unsignedp; +- return mode; ++ x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, rperm)); ++ x = gen_rtx_VEC_SELECT (GET_MODE (target), op0, x); ++ x = gen_rtx_SET (target, x); ++ ++ insn = emit_insn (x); ++ if (recog_memoized (insn) < 0) ++ { ++ remove_insn (insn); ++ return false; ++ } ++ return true; + } + +-/* Implement TARGET_STARTING_FRAME_OFFSET. See loongarch_compute_frame_info +- for details about the frame layout. */ ++/* Similar, but generate a vec_concat from op0 and op1 as well. */ + +-static HOST_WIDE_INT +-loongarch_starting_frame_offset (void) ++static bool ++loongarch_expand_vselect_vconcat (rtx target, rtx op0, rtx op1, ++ const unsigned char *perm, unsigned nelt) + { +- if (FRAME_GROWS_DOWNWARD) +- return 0; +- return crtl->outgoing_args_size; ++ machine_mode v2mode; ++ rtx x; ++ ++ if (!GET_MODE_2XWIDER_MODE (GET_MODE (op0)).exists (&v2mode)) ++ return false; ++ x = gen_rtx_VEC_CONCAT (v2mode, op0, op1); ++ return loongarch_expand_vselect (target, x, perm, nelt); + } + + static tree +@@ -6861,105 +7555,1291 @@ loongarch_set_handled_components (sbitmap components) + #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t" + #undef TARGET_ASM_ALIGNED_DI_OP + #define TARGET_ASM_ALIGNED_DI_OP "\t.dword\t" ++/* Construct (set target (vec_select op0 (parallel selector))) and ++ return true if that's a valid instruction in the active ISA. */ + +-#undef TARGET_OPTION_OVERRIDE +-#define TARGET_OPTION_OVERRIDE loongarch_option_override +- +-#undef TARGET_LEGITIMIZE_ADDRESS +-#define TARGET_LEGITIMIZE_ADDRESS loongarch_legitimize_address +- +-#undef TARGET_ASM_SELECT_RTX_SECTION +-#define TARGET_ASM_SELECT_RTX_SECTION loongarch_select_rtx_section +-#undef TARGET_ASM_FUNCTION_RODATA_SECTION +-#define TARGET_ASM_FUNCTION_RODATA_SECTION loongarch_function_rodata_section ++static bool ++loongarch_expand_lsx_shuffle (struct expand_vec_perm_d *d) ++{ ++ rtx x, eltsMAX_VECT_LEN; ++ rtvec v; ++ rtx_insn *insn; ++ unsigned i; + +-#undef TARGET_SCHED_INIT +-#define TARGET_SCHED_INIT loongarch_sched_init +-#undef TARGET_SCHED_REORDER +-#define TARGET_SCHED_REORDER loongarch_sched_reorder +-#undef TARGET_SCHED_REORDER2 +-#define TARGET_SCHED_REORDER2 loongarch_sched_reorder2 +-#undef TARGET_SCHED_VARIABLE_ISSUE +-#define TARGET_SCHED_VARIABLE_ISSUE loongarch_variable_issue +-#undef TARGET_SCHED_ADJUST_COST +-#define TARGET_SCHED_ADJUST_COST loongarch_adjust_cost +-#undef TARGET_SCHED_ISSUE_RATE +-#define TARGET_SCHED_ISSUE_RATE loongarch_issue_rate +-#undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD +-#define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \ +- loongarch_multipass_dfa_lookahead ++ if (!ISA_HAS_LSX) ++ return false; + +-#undef TARGET_FUNCTION_OK_FOR_SIBCALL +-#define TARGET_FUNCTION_OK_FOR_SIBCALL loongarch_function_ok_for_sibcall ++ for (i = 0; i < d->nelt; i++) ++ eltsi = GEN_INT (d->permi); + +-#undef TARGET_VALID_POINTER_MODE +-#define TARGET_VALID_POINTER_MODE loongarch_valid_pointer_mode +-#undef TARGET_REGISTER_MOVE_COST +-#define TARGET_REGISTER_MOVE_COST loongarch_register_move_cost +-#undef TARGET_MEMORY_MOVE_COST +-#define TARGET_MEMORY_MOVE_COST loongarch_memory_move_cost +-#undef TARGET_RTX_COSTS +-#define TARGET_RTX_COSTS loongarch_rtx_costs +-#undef TARGET_ADDRESS_COST +-#define TARGET_ADDRESS_COST loongarch_address_cost ++ v = gen_rtvec_v (d->nelt, elts); ++ x = gen_rtx_PARALLEL (VOIDmode, v); + +-#undef TARGET_IN_SMALL_DATA_P +-#define TARGET_IN_SMALL_DATA_P loongarch_in_small_data_p ++ if (!loongarch_const_vector_shuffle_set_p (x, d->vmode)) ++ return false; + +-#undef TARGET_PREFERRED_RELOAD_CLASS +-#define TARGET_PREFERRED_RELOAD_CLASS loongarch_preferred_reload_class ++ x = gen_rtx_VEC_SELECT (d->vmode, d->op0, x); ++ x = gen_rtx_SET (d->target, x); + +-#undef TARGET_ASM_FILE_START_FILE_DIRECTIVE +-#define TARGET_ASM_FILE_START_FILE_DIRECTIVE true ++ insn = emit_insn (x); ++ if (recog_memoized (insn) < 0) ++ { ++ remove_insn (insn); ++ return false; ++ } ++ return true; ++} + +-#undef TARGET_EXPAND_BUILTIN_VA_START +-#define TARGET_EXPAND_BUILTIN_VA_START loongarch_va_start ++void ++loongarch_expand_vec_perm (rtx target, rtx op0, rtx op1, rtx sel) ++{ ++ machine_mode vmode = GET_MODE (target); + +-#undef TARGET_PROMOTE_FUNCTION_MODE +-#define TARGET_PROMOTE_FUNCTION_MODE loongarch_promote_function_mode +-#undef TARGET_RETURN_IN_MEMORY +-#define TARGET_RETURN_IN_MEMORY loongarch_return_in_memory ++ switch (vmode) ++ { ++ case E_V16QImode: ++ emit_insn (gen_lsx_vshuf_b (target, op1, op0, sel)); ++ break; ++ case E_V2DFmode: ++ emit_insn (gen_lsx_vshuf_d_f (target, sel, op1, op0)); ++ break; ++ case E_V2DImode: ++ emit_insn (gen_lsx_vshuf_d (target, sel, op1, op0)); ++ break; ++ case E_V4SFmode: ++ emit_insn (gen_lsx_vshuf_w_f (target, sel, op1, op0)); ++ break; ++ case E_V4SImode: ++ emit_insn (gen_lsx_vshuf_w (target, sel, op1, op0)); ++ break; ++ case E_V8HImode: ++ emit_insn (gen_lsx_vshuf_h (target, sel, op1, op0)); ++ break; ++ default: ++ break; ++ } ++} + +-#undef TARGET_FUNCTION_VALUE +-#define TARGET_FUNCTION_VALUE loongarch_function_value +-#undef TARGET_LIBCALL_VALUE +-#define TARGET_LIBCALL_VALUE loongarch_libcall_value ++static bool ++loongarch_try_expand_lsx_vshuf_const (struct expand_vec_perm_d *d) ++{ ++ int i; ++ rtx target, op0, op1, sel, tmp; ++ rtx rpermMAX_VECT_LEN; + +-#undef TARGET_ASM_OUTPUT_MI_THUNK +-#define TARGET_ASM_OUTPUT_MI_THUNK loongarch_output_mi_thunk +-#undef TARGET_ASM_CAN_OUTPUT_MI_THUNK +-#define TARGET_ASM_CAN_OUTPUT_MI_THUNK \ +- hook_bool_const_tree_hwi_hwi_const_tree_true ++ if (d->vmode == E_V2DImode || d->vmode == E_V2DFmode ++ || d->vmode == E_V4SImode || d->vmode == E_V4SFmode ++ || d->vmode == E_V8HImode || d->vmode == E_V16QImode) ++ { ++ target = d->target; ++ op0 = d->op0; ++ op1 = d->one_vector_p ? d->op0 : d->op1; + +-#undef TARGET_PRINT_OPERAND +-#define TARGET_PRINT_OPERAND loongarch_print_operand +-#undef TARGET_PRINT_OPERAND_ADDRESS +-#define TARGET_PRINT_OPERAND_ADDRESS loongarch_print_operand_address +-#undef TARGET_PRINT_OPERAND_PUNCT_VALID_P +-#define TARGET_PRINT_OPERAND_PUNCT_VALID_P \ +- loongarch_print_operand_punct_valid_p ++ if (GET_MODE (op0) != GET_MODE (op1) ++ || GET_MODE (op0) != GET_MODE (target)) ++ return false; + +-#undef TARGET_SETUP_INCOMING_VARARGS +-#define TARGET_SETUP_INCOMING_VARARGS loongarch_setup_incoming_varargs +-#undef TARGET_STRICT_ARGUMENT_NAMING +-#define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true +-#undef TARGET_MUST_PASS_IN_STACK +-#define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size +-#undef TARGET_PASS_BY_REFERENCE +-#define TARGET_PASS_BY_REFERENCE loongarch_pass_by_reference +-#undef TARGET_ARG_PARTIAL_BYTES +-#define TARGET_ARG_PARTIAL_BYTES loongarch_arg_partial_bytes +-#undef TARGET_FUNCTION_ARG +-#define TARGET_FUNCTION_ARG loongarch_function_arg +-#undef TARGET_FUNCTION_ARG_ADVANCE +-#define TARGET_FUNCTION_ARG_ADVANCE loongarch_function_arg_advance +-#undef TARGET_FUNCTION_ARG_BOUNDARY +-#define TARGET_FUNCTION_ARG_BOUNDARY loongarch_function_arg_boundary ++ if (d->testing_p) ++ return true; + +-#undef TARGET_SCALAR_MODE_SUPPORTED_P +-#define TARGET_SCALAR_MODE_SUPPORTED_P loongarch_scalar_mode_supported_p ++ for (i = 0; i < d->nelt; i += 1) ++ { ++ rpermi = GEN_INT (d->permi); ++ } + +-#undef TARGET_INIT_BUILTINS ++ if (d->vmode == E_V2DFmode) ++ { ++ sel = gen_rtx_CONST_VECTOR (E_V2DImode, gen_rtvec_v (d->nelt, rperm)); ++ tmp = gen_rtx_SUBREG (E_V2DImode, d->target, 0); ++ emit_move_insn (tmp, sel); ++ } ++ else if (d->vmode == E_V4SFmode) ++ { ++ sel = gen_rtx_CONST_VECTOR (E_V4SImode, gen_rtvec_v (d->nelt, rperm)); ++ tmp = gen_rtx_SUBREG (E_V4SImode, d->target, 0); ++ emit_move_insn (tmp, sel); ++ } ++ else ++ { ++ sel = gen_rtx_CONST_VECTOR (d->vmode, gen_rtvec_v (d->nelt, rperm)); ++ emit_move_insn (d->target, sel); ++ } ++ ++ switch (d->vmode) ++ { ++ case E_V2DFmode: ++ emit_insn (gen_lsx_vshuf_d_f (target, target, op1, op0)); ++ break; ++ case E_V2DImode: ++ emit_insn (gen_lsx_vshuf_d (target, target, op1, op0)); ++ break; ++ case E_V4SFmode: ++ emit_insn (gen_lsx_vshuf_w_f (target, target, op1, op0)); ++ break; ++ case E_V4SImode: ++ emit_insn (gen_lsx_vshuf_w (target, target, op1, op0)); ++ break; ++ case E_V8HImode: ++ emit_insn (gen_lsx_vshuf_h (target, target, op1, op0)); ++ break; ++ case E_V16QImode: ++ emit_insn (gen_lsx_vshuf_b (target, op1, op0, target)); ++ break; ++ default: ++ break; ++ } ++ ++ return true; ++ } ++ return false; ++} ++ ++static bool ++loongarch_expand_vec_perm_const_1 (struct expand_vec_perm_d *d) ++{ ++ unsigned int i, nelt = d->nelt; ++ unsigned char perm2MAX_VECT_LEN; ++ ++ if (d->one_vector_p) ++ { ++ /* Try interleave with alternating operands. */ ++ memcpy (perm2, d->perm, sizeof (perm2)); ++ for (i = 1; i < nelt; i += 2) ++ perm2i += nelt; ++ if (loongarch_expand_vselect_vconcat (d->target, d->op0, d->op1, perm2, ++ nelt)) ++ return true; ++ } ++ else ++ { ++ if (loongarch_expand_vselect_vconcat (d->target, d->op0, d->op1, ++ d->perm, nelt)) ++ return true; ++ ++ /* Try again with swapped operands. */ ++ for (i = 0; i < nelt; ++i) ++ perm2i = (d->permi + nelt) & (2 * nelt - 1); ++ if (loongarch_expand_vselect_vconcat (d->target, d->op1, d->op0, perm2, ++ nelt)) ++ return true; ++ } ++ ++ if (loongarch_expand_lsx_shuffle (d)) ++ return true; ++ return false; ++} ++ ++/* Implementation of constant vector permuatation. This function identifies ++ * recognized pattern of permuation selector argument, and use one or more ++ * instruction(s) to finish the permutation job correctly. For unsupported ++ * patterns, it will return false. */ ++ ++static bool ++loongarch_expand_vec_perm_const_2 (struct expand_vec_perm_d *d) ++{ ++ /* Although we have the LSX vec_perm<mode> template, there's still some ++ 128bit vector permuatation operations send to vectorize_vec_perm_const. ++ In this case, we just simpliy wrap them by single vshuf.* instruction, ++ because LSX vshuf.* instruction just have the same behavior that GCC ++ expects. */ ++ return loongarch_try_expand_lsx_vshuf_const (d); ++} ++ ++/* Implement TARGET_VECTORIZE_VEC_PERM_CONST. */ ++ ++static bool ++loongarch_vectorize_vec_perm_const (machine_mode vmode, machine_mode op_mode, ++ rtx target, rtx op0, rtx op1, ++ const vec_perm_indices &sel) ++{ ++ if (vmode != op_mode) ++ return false; ++ ++ struct expand_vec_perm_d d; ++ int i, nelt, which; ++ unsigned char orig_permMAX_VECT_LEN; ++ bool ok; ++ ++ d.target = target; ++ if (op0) ++ { ++ rtx nop0 = force_reg (vmode, op0); ++ if (op0 == op1) ++ op1 = nop0; ++ op0 = nop0; ++ } ++ if (op1) ++ op1 = force_reg (vmode, op1); ++ d.op0 = op0; ++ d.op1 = op1; ++ ++ d.vmode = vmode; ++ gcc_assert (VECTOR_MODE_P (vmode)); ++ d.nelt = nelt = GET_MODE_NUNITS (vmode); ++ d.testing_p = !target; ++ ++ /* This is overly conservative, but ensures we don't get an ++ uninitialized warning on ORIG_PERM. */ ++ memset (orig_perm, 0, MAX_VECT_LEN); ++ for (i = which = 0; i < nelt; ++i) ++ { ++ int ei = seli & (2 * nelt - 1); ++ which |= (ei < nelt ? 1 : 2); ++ orig_permi = ei; ++ } ++ memcpy (d.perm, orig_perm, MAX_VECT_LEN); ++ ++ switch (which) ++ { ++ default: ++ gcc_unreachable (); ++ ++ case 3: ++ d.one_vector_p = false; ++ if (d.testing_p || !rtx_equal_p (d.op0, d.op1)) ++ break; ++ /* FALLTHRU */ ++ ++ case 2: ++ for (i = 0; i < nelt; ++i) ++ d.permi &= nelt - 1; ++ d.op0 = d.op1; ++ d.one_vector_p = true; ++ break; ++ ++ case 1: ++ d.op1 = d.op0; ++ d.one_vector_p = true; ++ break; ++ } ++ ++ if (d.testing_p) ++ { ++ d.target = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 1); ++ d.op1 = d.op0 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 2); ++ if (!d.one_vector_p) ++ d.op1 = gen_raw_REG (d.vmode, LAST_VIRTUAL_REGISTER + 3); ++ ++ ok = loongarch_expand_vec_perm_const_2 (&d); ++ if (ok) ++ return ok; ++ ++ start_sequence (); ++ ok = loongarch_expand_vec_perm_const_1 (&d); ++ end_sequence (); ++ return ok; ++ } ++ ++ ok = loongarch_expand_vec_perm_const_2 (&d); ++ if (!ok) ++ ok = loongarch_expand_vec_perm_const_1 (&d); ++ ++ /* If we were given a two-vector permutation which just happened to ++ have both input vectors equal, we folded this into a one-vector ++ permutation. There are several loongson patterns that are matched ++ via direct vec_select+vec_concat expansion, but we do not have ++ support in loongarch_expand_vec_perm_const_1 to guess the adjustment ++ that should be made for a single operand. Just try again with ++ the original permutation. */ ++ if (!ok && which == 3) ++ { ++ d.op0 = op0; ++ d.op1 = op1; ++ d.one_vector_p = false; ++ memcpy (d.perm, orig_perm, MAX_VECT_LEN); ++ ok = loongarch_expand_vec_perm_const_1 (&d); ++ } ++ ++ return ok; ++} ++ ++static int ++loongarch_cpu_sched_reassociation_width (struct loongarch_target *target, ++ unsigned int opc, machine_mode mode) ++{ ++ /* unreferenced argument */ ++ (void) opc; ++ ++ switch (target->cpu_tune) ++ { ++ case CPU_LOONGARCH64: ++ case CPU_LA464: ++ /* Vector part. */ ++ if (LSX_SUPPORTED_MODE_P (mode)) ++ { ++ /* Integer vector instructions execute in FP unit. ++ The width of integer/float-point vector instructions is 3. */ ++ return 3; ++ } ++ ++ /* Scalar part. */ ++ else if (INTEGRAL_MODE_P (mode)) ++ return 1; ++ else if (FLOAT_MODE_P (mode)) ++ { ++ if (opc == PLUS_EXPR) ++ { ++ return 2; ++ } ++ return 4; ++ } ++ break; ++ default: ++ break; ++ } ++ ++ /* default is 1 */ ++ return 1; ++} ++ ++/* Implement TARGET_SCHED_REASSOCIATION_WIDTH. */ ++ ++static int ++loongarch_sched_reassociation_width (unsigned int opc, machine_mode mode) ++{ ++ return loongarch_cpu_sched_reassociation_width (&la_target, opc, mode); ++} ++ ++/* Implement extract a scalar element from vecotr register */ ++ ++void ++loongarch_expand_vector_extract (rtx target, rtx vec, int elt) ++{ ++ machine_mode mode = GET_MODE (vec); ++ machine_mode inner_mode = GET_MODE_INNER (mode); ++ rtx tmp; ++ ++ switch (mode) ++ { ++ case E_V8HImode: ++ case E_V16QImode: ++ break; ++ ++ default: ++ break; ++ } ++ ++ tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, GEN_INT (elt))); ++ tmp = gen_rtx_VEC_SELECT (inner_mode, vec, tmp); ++ ++ /* Let the rtl optimizers know about the zero extension performed. */ ++ if (inner_mode == QImode || inner_mode == HImode) ++ { ++ tmp = gen_rtx_ZERO_EXTEND (SImode, tmp); ++ target = gen_lowpart (SImode, target); ++ } ++ if (inner_mode == SImode || inner_mode == DImode) ++ { ++ tmp = gen_rtx_SIGN_EXTEND (inner_mode, tmp); ++ } ++ ++ emit_insn (gen_rtx_SET (target, tmp)); ++} ++ ++/* Generate code to copy vector bits i / 2 ... i - 1 from vector SRC ++ to bits 0 ... i / 2 - 1 of vector DEST, which has the same mode. ++ The upper bits of DEST are undefined, though they shouldn't cause ++ exceptions (some bits from src or all zeros are ok). */ ++ ++static void ++emit_reduc_half (rtx dest, rtx src, int i) ++{ ++ rtx tem, d = dest; ++ switch (GET_MODE (src)) ++ { ++ case E_V4SFmode: ++ tem = gen_lsx_vbsrl_w_f (dest, src, GEN_INT (i == 128 ? 8 : 4)); ++ break; ++ case E_V2DFmode: ++ tem = gen_lsx_vbsrl_d_f (dest, src, GEN_INT (8)); ++ break; ++ case E_V16QImode: ++ case E_V8HImode: ++ case E_V4SImode: ++ case E_V2DImode: ++ d = gen_reg_rtx (V2DImode); ++ tem = gen_lsx_vbsrl_d (d, gen_lowpart (V2DImode, src), GEN_INT (i/16)); ++ break; ++ default: ++ gcc_unreachable (); ++ } ++ emit_insn (tem); ++ if (d != dest) ++ emit_move_insn (dest, gen_lowpart (GET_MODE (dest), d)); ++} ++ ++/* Expand a vector reduction. FN is the binary pattern to reduce; ++ DEST is the destination; IN is the input vector. */ ++ ++void ++loongarch_expand_vector_reduc (rtx (*fn) (rtx, rtx, rtx), rtx dest, rtx in) ++{ ++ rtx half, dst, vec = in; ++ machine_mode mode = GET_MODE (in); ++ int i; ++ ++ for (i = GET_MODE_BITSIZE (mode); ++ i > GET_MODE_UNIT_BITSIZE (mode); ++ i >>= 1) ++ { ++ half = gen_reg_rtx (mode); ++ emit_reduc_half (half, vec, i); ++ if (i == GET_MODE_UNIT_BITSIZE (mode) * 2) ++ dst = dest; ++ else ++ dst = gen_reg_rtx (mode); ++ emit_insn (fn (dst, half, vec)); ++ vec = dst; ++ } ++} ++ ++/* Expand an integral vector unpack operation. */ ++ ++void ++loongarch_expand_vec_unpack (rtx operands2, bool unsigned_p, bool high_p) ++{ ++ machine_mode imode = GET_MODE (operands1); ++ rtx (*unpack) (rtx, rtx, rtx); ++ rtx (*cmpFunc) (rtx, rtx, rtx); ++ rtx tmp, dest; ++ ++ if (ISA_HAS_LSX) ++ { ++ switch (imode) ++ { ++ case E_V4SImode: ++ if (high_p != 0) ++ unpack = gen_lsx_vilvh_w; ++ else ++ unpack = gen_lsx_vilvl_w; ++ ++ cmpFunc = gen_lsx_vslt_w; ++ break; ++ ++ case E_V8HImode: ++ if (high_p != 0) ++ unpack = gen_lsx_vilvh_h; ++ else ++ unpack = gen_lsx_vilvl_h; ++ ++ cmpFunc = gen_lsx_vslt_h; ++ break; ++ ++ case E_V16QImode: ++ if (high_p != 0) ++ unpack = gen_lsx_vilvh_b; ++ else ++ unpack = gen_lsx_vilvl_b; ++ ++ cmpFunc = gen_lsx_vslt_b; ++ break; ++ ++ default: ++ gcc_unreachable (); ++ break; ++ } ++ ++ if (!unsigned_p) ++ { ++ /* Extract sign extention for each element comparing each element ++ with immediate zero. */ ++ tmp = gen_reg_rtx (imode); ++ emit_insn (cmpFunc (tmp, operands1, CONST0_RTX (imode))); ++ } ++ else ++ tmp = force_reg (imode, CONST0_RTX (imode)); ++ ++ dest = gen_reg_rtx (imode); ++ ++ emit_insn (unpack (dest, operands1, tmp)); ++ emit_move_insn (operands0, gen_lowpart (GET_MODE (operands0), dest)); ++ return; ++ } ++ gcc_unreachable (); ++} ++ ++/* Construct and return PARALLEL RTX with CONST_INTs for HIGH (high_p == TRUE) ++ or LOW (high_p == FALSE) half of a vector for mode MODE. */ ++ ++rtx ++loongarch_lsx_vec_parallel_const_half (machine_mode mode, bool high_p) ++{ ++ int nunits = GET_MODE_NUNITS (mode); ++ rtvec v = rtvec_alloc (nunits / 2); ++ int base; ++ int i; ++ ++ base = high_p ? nunits / 2 : 0; ++ ++ for (i = 0; i < nunits / 2; i++) ++ RTVEC_ELT (v, i) = GEN_INT (base + i); ++ ++ return gen_rtx_PARALLEL (VOIDmode, v); ++} ++ ++/* A subroutine of loongarch_expand_vec_init, match constant vector ++ elements. */ ++ ++static inline bool ++loongarch_constant_elt_p (rtx x) ++{ ++ return CONST_INT_P (x) || GET_CODE (x) == CONST_DOUBLE; ++} ++ ++rtx ++loongarch_gen_const_int_vector_shuffle (machine_mode mode, int val) ++{ ++ int nunits = GET_MODE_NUNITS (mode); ++ int nsets = nunits / 4; ++ rtx eltsMAX_VECT_LEN; ++ int set = 0; ++ int i, j; ++ ++ /* Generate a const_int vector replicating the same 4-element set ++ from an immediate. */ ++ for (j = 0; j < nsets; j++, set = 4 * j) ++ for (i = 0; i < 4; i++) ++ eltsset + i = GEN_INT (set + ((val >> (2 * i)) & 0x3)); ++ ++ return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nunits, elts)); ++} ++ ++/* Expand a vector initialization. */ ++ ++void ++loongarch_expand_vector_init (rtx target, rtx vals) ++{ ++ machine_mode vmode = GET_MODE (target); ++ machine_mode imode = GET_MODE_INNER (vmode); ++ unsigned i, nelt = GET_MODE_NUNITS (vmode); ++ unsigned nvar = 0; ++ bool all_same = true; ++ rtx x; ++ ++ for (i = 0; i < nelt; ++i) ++ { ++ x = XVECEXP (vals, 0, i); ++ if (!loongarch_constant_elt_p (x)) ++ nvar++; ++ if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0))) ++ all_same = false; ++ } ++ ++ if (ISA_HAS_LSX) ++ { ++ if (all_same) ++ { ++ rtx same = XVECEXP (vals, 0, 0); ++ rtx temp, temp2; ++ ++ if (CONST_INT_P (same) && nvar == 0 ++ && loongarch_signed_immediate_p (INTVAL (same), 10, 0)) ++ { ++ switch (vmode) ++ { ++ case E_V16QImode: ++ case E_V8HImode: ++ case E_V4SImode: ++ case E_V2DImode: ++ temp = gen_rtx_CONST_VECTOR (vmode, XVEC (vals, 0)); ++ emit_move_insn (target, temp); ++ return; ++ ++ default: ++ gcc_unreachable (); ++ } ++ } ++ temp = gen_reg_rtx (imode); ++ if (imode == GET_MODE (same)) ++ temp2 = same; ++ else if (GET_MODE_SIZE (imode) >= UNITS_PER_WORD) ++ { ++ if (GET_CODE (same) == MEM) ++ { ++ rtx reg_tmp = gen_reg_rtx (GET_MODE (same)); ++ loongarch_emit_move (reg_tmp, same); ++ temp2 = simplify_gen_subreg (imode, reg_tmp, ++ GET_MODE (reg_tmp), 0); ++ } ++ else ++ temp2 = simplify_gen_subreg (imode, same, GET_MODE (same), 0); ++ } ++ else ++ { ++ if (GET_CODE (same) == MEM) ++ { ++ rtx reg_tmp = gen_reg_rtx (GET_MODE (same)); ++ loongarch_emit_move (reg_tmp, same); ++ temp2 = lowpart_subreg (imode, reg_tmp, GET_MODE (reg_tmp)); ++ } ++ else ++ temp2 = lowpart_subreg (imode, same, GET_MODE (same)); ++ } ++ emit_move_insn (temp, temp2); ++ ++ switch (vmode) ++ { ++ case E_V16QImode: ++ case E_V8HImode: ++ case E_V4SImode: ++ case E_V2DImode: ++ loongarch_emit_move (target, gen_rtx_VEC_DUPLICATE (vmode, temp)); ++ break; ++ ++ case E_V4SFmode: ++ emit_insn (gen_lsx_vreplvei_w_f_scalar (target, temp)); ++ break; ++ ++ case E_V2DFmode: ++ emit_insn (gen_lsx_vreplvei_d_f_scalar (target, temp)); ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ } ++ else ++ { ++ emit_move_insn (target, CONST0_RTX (vmode)); ++ ++ for (i = 0; i < nelt; ++i) ++ { ++ rtx temp = gen_reg_rtx (imode); ++ emit_move_insn (temp, XVECEXP (vals, 0, i)); ++ switch (vmode) ++ { ++ case E_V16QImode: ++ if (i == 0) ++ emit_insn (gen_lsx_vreplvei_b_scalar (target, temp)); ++ else ++ emit_insn (gen_vec_setv16qi (target, temp, GEN_INT (i))); ++ break; ++ ++ case E_V8HImode: ++ if (i == 0) ++ emit_insn (gen_lsx_vreplvei_h_scalar (target, temp)); ++ else ++ emit_insn (gen_vec_setv8hi (target, temp, GEN_INT (i))); ++ break; ++ ++ case E_V4SImode: ++ if (i == 0) ++ emit_insn (gen_lsx_vreplvei_w_scalar (target, temp)); ++ else ++ emit_insn (gen_vec_setv4si (target, temp, GEN_INT (i))); ++ break; ++ ++ case E_V2DImode: ++ if (i == 0) ++ emit_insn (gen_lsx_vreplvei_d_scalar (target, temp)); ++ else ++ emit_insn (gen_vec_setv2di (target, temp, GEN_INT (i))); ++ break; ++ ++ case E_V4SFmode: ++ if (i == 0) ++ emit_insn (gen_lsx_vreplvei_w_f_scalar (target, temp)); ++ else ++ emit_insn (gen_vec_setv4sf (target, temp, GEN_INT (i))); ++ break; ++ ++ case E_V2DFmode: ++ if (i == 0) ++ emit_insn (gen_lsx_vreplvei_d_f_scalar (target, temp)); ++ else ++ emit_insn (gen_vec_setv2df (target, temp, GEN_INT (i))); ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ } ++ } ++ return; ++ } ++ ++ /* Load constants from the pool, or whatever's handy. */ ++ if (nvar == 0) ++ { ++ emit_move_insn (target, gen_rtx_CONST_VECTOR (vmode, XVEC (vals, 0))); ++ return; ++ } ++ ++ /* For two-part initialization, always use CONCAT. */ ++ if (nelt == 2) ++ { ++ rtx op0 = force_reg (imode, XVECEXP (vals, 0, 0)); ++ rtx op1 = force_reg (imode, XVECEXP (vals, 0, 1)); ++ x = gen_rtx_VEC_CONCAT (vmode, op0, op1); ++ emit_insn (gen_rtx_SET (target, x)); ++ return; ++ } ++ ++ /* Loongson is the only cpu with vectors with more elements. */ ++ gcc_assert (0); ++} ++ ++/* Implement HARD_REGNO_CALLER_SAVE_MODE. */ ++ ++machine_mode ++loongarch_hard_regno_caller_save_mode (unsigned int regno, unsigned int nregs, ++ machine_mode mode) ++{ ++ /* For performance, avoid saving/restoring upper parts of a register ++ by returning MODE as save mode when the mode is known. */ ++ if (mode == VOIDmode) ++ return choose_hard_reg_mode (regno, nregs, NULL); ++ else ++ return mode; ++} ++ ++/* Generate RTL for comparing CMP_OP0 and CMP_OP1 using condition COND and ++ store the result -1 or 0 in DEST. */ ++ ++static void ++loongarch_expand_lsx_cmp (rtx dest, enum rtx_code cond, rtx op0, rtx op1) ++{ ++ machine_mode cmp_mode = GET_MODE (op0); ++ int unspec = -1; ++ bool negate = false; ++ ++ switch (cmp_mode) ++ { ++ case E_V16QImode: ++ case E_V32QImode: ++ case E_V8HImode: ++ case E_V16HImode: ++ case E_V4SImode: ++ case E_V8SImode: ++ case E_V2DImode: ++ case E_V4DImode: ++ switch (cond) ++ { ++ case NE: ++ cond = reverse_condition (cond); ++ negate = true; ++ break; ++ case EQ: ++ case LT: ++ case LE: ++ case LTU: ++ case LEU: ++ break; ++ case GE: ++ case GT: ++ case GEU: ++ case GTU: ++ std::swap (op0, op1); ++ cond = swap_condition (cond); ++ break; ++ default: ++ gcc_unreachable (); ++ } ++ loongarch_emit_binary (cond, dest, op0, op1); ++ if (negate) ++ emit_move_insn (dest, gen_rtx_NOT (GET_MODE (dest), dest)); ++ break; ++ ++ case E_V4SFmode: ++ case E_V2DFmode: ++ switch (cond) ++ { ++ case UNORDERED: ++ case ORDERED: ++ case EQ: ++ case NE: ++ case UNEQ: ++ case UNLE: ++ case UNLT: ++ break; ++ case LTGT: cond = NE; break; ++ case UNGE: cond = UNLE; std::swap (op0, op1); break; ++ case UNGT: cond = UNLT; std::swap (op0, op1); break; ++ case LE: unspec = UNSPEC_LSX_VFCMP_SLE; break; ++ case LT: unspec = UNSPEC_LSX_VFCMP_SLT; break; ++ case GE: unspec = UNSPEC_LSX_VFCMP_SLE; std::swap (op0, op1); break; ++ case GT: unspec = UNSPEC_LSX_VFCMP_SLT; std::swap (op0, op1); break; ++ default: ++ gcc_unreachable (); ++ } ++ if (unspec < 0) ++ loongarch_emit_binary (cond, dest, op0, op1); ++ else ++ { ++ rtx x = gen_rtx_UNSPEC (GET_MODE (dest), ++ gen_rtvec (2, op0, op1), unspec); ++ emit_insn (gen_rtx_SET (dest, x)); ++ } ++ break; ++ ++ default: ++ gcc_unreachable (); ++ break; ++ } ++} ++ ++/* Expand VEC_COND_EXPR, where: ++ MODE is mode of the result ++ VIMODE equivalent integer mode ++ OPERANDS operands of VEC_COND_EXPR. */ ++ ++void ++loongarch_expand_vec_cond_expr (machine_mode mode, machine_mode vimode, ++ rtx *operands) ++{ ++ rtx cond = operands3; ++ rtx cmp_op0 = operands4; ++ rtx cmp_op1 = operands5; ++ rtx cmp_res = gen_reg_rtx (vimode); ++ ++ loongarch_expand_lsx_cmp (cmp_res, GET_CODE (cond), cmp_op0, cmp_op1); ++ ++ /* We handle the following cases: ++ 1) r = a CMP b ? -1 : 0 ++ 2) r = a CMP b ? -1 : v ++ 3) r = a CMP b ? v : 0 ++ 4) r = a CMP b ? v1 : v2 */ ++ ++ /* Case (1) above. We only move the results. */ ++ if (operands1 == CONSTM1_RTX (vimode) ++ && operands2 == CONST0_RTX (vimode)) ++ emit_move_insn (operands0, cmp_res); ++ else ++ { ++ rtx src1 = gen_reg_rtx (vimode); ++ rtx src2 = gen_reg_rtx (vimode); ++ rtx mask = gen_reg_rtx (vimode); ++ rtx bsel; ++ ++ /* Move the vector result to use it as a mask. */ ++ emit_move_insn (mask, cmp_res); ++ ++ if (register_operand (operands1, mode)) ++ { ++ rtx xop1 = operands1; ++ if (mode != vimode) ++ { ++ xop1 = gen_reg_rtx (vimode); ++ emit_move_insn (xop1, gen_rtx_SUBREG (vimode, operands1, 0)); ++ } ++ emit_move_insn (src1, xop1); ++ } ++ else ++ { ++ gcc_assert (operands1 == CONSTM1_RTX (vimode)); ++ /* Case (2) if the below doesn't move the mask to src2. */ ++ emit_move_insn (src1, mask); ++ } ++ ++ if (register_operand (operands2, mode)) ++ { ++ rtx xop2 = operands2; ++ if (mode != vimode) ++ { ++ xop2 = gen_reg_rtx (vimode); ++ emit_move_insn (xop2, gen_rtx_SUBREG (vimode, operands2, 0)); ++ } ++ emit_move_insn (src2, xop2); ++ } ++ else ++ { ++ gcc_assert (operands2 == CONST0_RTX (mode)); ++ /* Case (3) if the above didn't move the mask to src1. */ ++ emit_move_insn (src2, mask); ++ } ++ ++ /* We deal with case (4) if the mask wasn't moved to either src1 or src2. ++ In any case, we eventually do vector mask-based copy. */ ++ bsel = gen_rtx_IOR (vimode, ++ gen_rtx_AND (vimode, ++ gen_rtx_NOT (vimode, mask), src2), ++ gen_rtx_AND (vimode, mask, src1)); ++ /* The result is placed back to a register with the mask. */ ++ emit_insn (gen_rtx_SET (mask, bsel)); ++ emit_move_insn (operands0, gen_rtx_SUBREG (mode, mask, 0)); ++ } ++} ++ ++void ++loongarch_expand_vec_cond_mask_expr (machine_mode mode, machine_mode vimode, ++ rtx *operands) ++{ ++ rtx cmp_res = operands3; ++ ++ /* We handle the following cases: ++ 1) r = a CMP b ? -1 : 0 ++ 2) r = a CMP b ? -1 : v ++ 3) r = a CMP b ? v : 0 ++ 4) r = a CMP b ? v1 : v2 */ ++ ++ /* Case (1) above. We only move the results. */ ++ if (operands1 == CONSTM1_RTX (vimode) ++ && operands2 == CONST0_RTX (vimode)) ++ emit_move_insn (operands0, cmp_res); ++ else ++ { ++ rtx src1 = gen_reg_rtx (vimode); ++ rtx src2 = gen_reg_rtx (vimode); ++ rtx mask = gen_reg_rtx (vimode); ++ rtx bsel; ++ ++ /* Move the vector result to use it as a mask. */ ++ emit_move_insn (mask, cmp_res); ++ ++ if (register_operand (operands1, mode)) ++ { ++ rtx xop1 = operands1; ++ if (mode != vimode) ++ { ++ xop1 = gen_reg_rtx (vimode); ++ emit_move_insn (xop1, gen_rtx_SUBREG (vimode, operands1, 0)); ++ } ++ emit_move_insn (src1, xop1); ++ } ++ else ++ { ++ gcc_assert (operands1 == CONSTM1_RTX (vimode)); ++ /* Case (2) if the below doesn't move the mask to src2. */ ++ emit_move_insn (src1, mask); ++ } ++ ++ if (register_operand (operands2, mode)) ++ { ++ rtx xop2 = operands2; ++ if (mode != vimode) ++ { ++ xop2 = gen_reg_rtx (vimode); ++ emit_move_insn (xop2, gen_rtx_SUBREG (vimode, operands2, 0)); ++ } ++ emit_move_insn (src2, xop2); ++ } ++ else ++ { ++ gcc_assert (operands2 == CONST0_RTX (mode)); ++ /* Case (3) if the above didn't move the mask to src1. */ ++ emit_move_insn (src2, mask); ++ } ++ ++ /* We deal with case (4) if the mask wasn't moved to either src1 or src2. ++ In any case, we eventually do vector mask-based copy. */ ++ bsel = gen_rtx_IOR (vimode, ++ gen_rtx_AND (vimode, ++ gen_rtx_NOT (vimode, mask), src2), ++ gen_rtx_AND (vimode, mask, src1)); ++ /* The result is placed back to a register with the mask. */ ++ emit_insn (gen_rtx_SET (mask, bsel)); ++ emit_move_insn (operands0, gen_rtx_SUBREG (mode, mask, 0)); ++ } ++} ++ ++/* Expand integer vector comparison */ ++bool ++loongarch_expand_vec_cmp (rtx operands) ++{ ++ ++ rtx_code code = GET_CODE (operands1); ++ loongarch_expand_lsx_cmp (operands0, code, operands2, operands3); ++ return true; ++} ++ ++/* Implement TARGET_CASE_VALUES_THRESHOLD. */ ++ ++unsigned int ++loongarch_case_values_threshold (void) ++{ ++ return default_case_values_threshold (); ++} ++ ++/* Implement TARGET_SPILL_CLASS. */ ++ ++static reg_class_t ++loongarch_spill_class (reg_class_t rclass ATTRIBUTE_UNUSED, ++ machine_mode mode ATTRIBUTE_UNUSED) ++{ ++ return NO_REGS; ++} ++ ++/* Implement TARGET_PROMOTE_FUNCTION_MODE. */ ++ ++/* This function is equivalent to default_promote_function_mode_always_promote ++ except that it returns a promoted mode even if type is NULL_TREE. This is ++ needed by libcalls which have no type (only a mode) such as fixed conversion ++ routines that take a signed or unsigned char/short argument and convert it ++ to a fixed type. */ ++ ++static machine_mode ++loongarch_promote_function_mode (const_tree type ATTRIBUTE_UNUSED, ++ machine_mode mode, ++ int *punsignedp ATTRIBUTE_UNUSED, ++ const_tree fntype ATTRIBUTE_UNUSED, ++ int for_return ATTRIBUTE_UNUSED) ++{ ++ int unsignedp; ++ ++ if (type != NULL_TREE) ++ return promote_mode (type, mode, punsignedp); ++ ++ unsignedp = *punsignedp; ++ PROMOTE_MODE (mode, unsignedp, type); ++ *punsignedp = unsignedp; ++ return mode; ++} ++ ++/* Implement TARGET_STARTING_FRAME_OFFSET. See loongarch_compute_frame_info ++ for details about the frame layout. */ ++ ++static HOST_WIDE_INT ++loongarch_starting_frame_offset (void) ++{ ++ if (FRAME_GROWS_DOWNWARD) ++ return 0; ++ return crtl->outgoing_args_size; ++} ++ ++/* A subroutine of loongarch_build_signbit_mask. If VECT is true, ++ then replicate the value for all elements of the vector ++ register. */ ++ ++rtx ++loongarch_build_const_vector (machine_mode mode, bool vect, rtx value) ++{ ++ int i, n_elt; ++ rtvec v; ++ machine_mode scalar_mode; ++ ++ switch (mode) ++ { ++ case E_V32QImode: ++ case E_V16QImode: ++ case E_V32HImode: ++ case E_V16HImode: ++ case E_V8HImode: ++ case E_V8SImode: ++ case E_V4SImode: ++ case E_V8DImode: ++ case E_V4DImode: ++ case E_V2DImode: ++ gcc_assert (vect); ++ /* FALLTHRU */ ++ case E_V8SFmode: ++ case E_V4SFmode: ++ case E_V8DFmode: ++ case E_V4DFmode: ++ case E_V2DFmode: ++ n_elt = GET_MODE_NUNITS (mode); ++ v = rtvec_alloc (n_elt); ++ scalar_mode = GET_MODE_INNER (mode); ++ ++ RTVEC_ELT (v, 0) = value; ++ ++ for (i = 1; i < n_elt; ++i) ++ RTVEC_ELT (v, i) = vect ? value : CONST0_RTX (scalar_mode); ++ ++ return gen_rtx_CONST_VECTOR (mode, v); ++ ++ default: ++ gcc_unreachable (); ++ } ++} ++ ++/* Create a mask for the sign bit in MODE ++ for an register. If VECT is true, then replicate the mask for ++ all elements of the vector register. If INVERT is true, then create ++ a mask excluding the sign bit. */ ++ ++rtx ++loongarch_build_signbit_mask (machine_mode mode, bool vect, bool invert) ++{ ++ machine_mode vec_mode, imode; ++ wide_int w; ++ rtx mask, v; ++ ++ switch (mode) ++ { ++ case E_V16SImode: ++ case E_V16SFmode: ++ case E_V8SImode: ++ case E_V4SImode: ++ case E_V8SFmode: ++ case E_V4SFmode: ++ vec_mode = mode; ++ imode = SImode; ++ break; ++ ++ case E_V8DImode: ++ case E_V4DImode: ++ case E_V2DImode: ++ case E_V8DFmode: ++ case E_V4DFmode: ++ case E_V2DFmode: ++ vec_mode = mode; ++ imode = DImode; ++ break; ++ ++ case E_TImode: ++ case E_TFmode: ++ vec_mode = VOIDmode; ++ imode = TImode; ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ ++ machine_mode inner_mode = GET_MODE_INNER (mode); ++ w = wi::set_bit_in_zero (GET_MODE_BITSIZE (inner_mode) - 1, ++ GET_MODE_BITSIZE (inner_mode)); ++ if (invert) ++ w = wi::bit_not (w); ++ ++ /* Force this value into the low part of a fp vector constant. */ ++ mask = immed_wide_int_const (w, imode); ++ mask = gen_lowpart (inner_mode, mask); ++ ++ if (vec_mode == VOIDmode) ++ return force_reg (inner_mode, mask); ++ ++ v = loongarch_build_const_vector (vec_mode, vect, mask); ++ return force_reg (vec_mode, v); ++} ++ ++static bool ++loongarch_builtin_support_vector_misalignment (machine_mode mode, ++ const_tree type, ++ int misalignment, ++ bool is_packed) ++{ ++ if (ISA_HAS_LSX && STRICT_ALIGNMENT) ++ { ++ if (optab_handler (movmisalign_optab, mode) == CODE_FOR_nothing) ++ return false; ++ if (misalignment == -1) ++ return false; ++ } ++ return default_builtin_support_vector_misalignment (mode, type, misalignment, ++ is_packed); ++} ++ ++/* Initialize the GCC target structure. */ ++#undef TARGET_ASM_ALIGNED_HI_OP ++#define TARGET_ASM_ALIGNED_HI_OP "\t.half\t" ++#undef TARGET_ASM_ALIGNED_SI_OP ++#define TARGET_ASM_ALIGNED_SI_OP "\t.word\t" ++#undef TARGET_ASM_ALIGNED_DI_OP ++#define TARGET_ASM_ALIGNED_DI_OP "\t.dword\t" ++ ++#undef TARGET_OPTION_OVERRIDE ++#define TARGET_OPTION_OVERRIDE loongarch_option_override ++ ++#undef TARGET_LEGITIMIZE_ADDRESS ++#define TARGET_LEGITIMIZE_ADDRESS loongarch_legitimize_address ++ ++#undef TARGET_ASM_SELECT_RTX_SECTION ++#define TARGET_ASM_SELECT_RTX_SECTION loongarch_select_rtx_section ++#undef TARGET_ASM_FUNCTION_RODATA_SECTION ++#define TARGET_ASM_FUNCTION_RODATA_SECTION loongarch_function_rodata_section ++ ++#undef TARGET_SCHED_INIT ++#define TARGET_SCHED_INIT loongarch_sched_init ++#undef TARGET_SCHED_REORDER ++#define TARGET_SCHED_REORDER loongarch_sched_reorder ++#undef TARGET_SCHED_REORDER2 ++#define TARGET_SCHED_REORDER2 loongarch_sched_reorder2 ++#undef TARGET_SCHED_VARIABLE_ISSUE ++#define TARGET_SCHED_VARIABLE_ISSUE loongarch_variable_issue ++#undef TARGET_SCHED_ADJUST_COST ++#define TARGET_SCHED_ADJUST_COST loongarch_adjust_cost ++#undef TARGET_SCHED_ISSUE_RATE ++#define TARGET_SCHED_ISSUE_RATE loongarch_issue_rate ++#undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ++#define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \ ++ loongarch_multipass_dfa_lookahead ++ ++#undef TARGET_FUNCTION_OK_FOR_SIBCALL ++#define TARGET_FUNCTION_OK_FOR_SIBCALL loongarch_function_ok_for_sibcall ++ ++#undef TARGET_VALID_POINTER_MODE ++#define TARGET_VALID_POINTER_MODE loongarch_valid_pointer_mode ++#undef TARGET_REGISTER_MOVE_COST ++#define TARGET_REGISTER_MOVE_COST loongarch_register_move_cost ++#undef TARGET_MEMORY_MOVE_COST ++#define TARGET_MEMORY_MOVE_COST loongarch_memory_move_cost ++#undef TARGET_RTX_COSTS ++#define TARGET_RTX_COSTS loongarch_rtx_costs ++#undef TARGET_ADDRESS_COST ++#define TARGET_ADDRESS_COST loongarch_address_cost ++#undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST ++#define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \ ++ loongarch_builtin_vectorization_cost ++ ++ ++#undef TARGET_IN_SMALL_DATA_P ++#define TARGET_IN_SMALL_DATA_P loongarch_in_small_data_p ++ ++#undef TARGET_PREFERRED_RELOAD_CLASS ++#define TARGET_PREFERRED_RELOAD_CLASS loongarch_preferred_reload_class ++ ++#undef TARGET_ASM_FILE_START_FILE_DIRECTIVE ++#define TARGET_ASM_FILE_START_FILE_DIRECTIVE true ++ ++#undef TARGET_EXPAND_BUILTIN_VA_START ++#define TARGET_EXPAND_BUILTIN_VA_START loongarch_va_start ++ ++#undef TARGET_PROMOTE_FUNCTION_MODE ++#define TARGET_PROMOTE_FUNCTION_MODE loongarch_promote_function_mode ++#undef TARGET_RETURN_IN_MEMORY ++#define TARGET_RETURN_IN_MEMORY loongarch_return_in_memory ++ ++#undef TARGET_FUNCTION_VALUE ++#define TARGET_FUNCTION_VALUE loongarch_function_value ++#undef TARGET_LIBCALL_VALUE ++#define TARGET_LIBCALL_VALUE loongarch_libcall_value ++ ++#undef TARGET_ASM_OUTPUT_MI_THUNK ++#define TARGET_ASM_OUTPUT_MI_THUNK loongarch_output_mi_thunk ++#undef TARGET_ASM_CAN_OUTPUT_MI_THUNK ++#define TARGET_ASM_CAN_OUTPUT_MI_THUNK \ ++ hook_bool_const_tree_hwi_hwi_const_tree_true ++ ++#undef TARGET_PRINT_OPERAND ++#define TARGET_PRINT_OPERAND loongarch_print_operand ++#undef TARGET_PRINT_OPERAND_ADDRESS ++#define TARGET_PRINT_OPERAND_ADDRESS loongarch_print_operand_address ++#undef TARGET_PRINT_OPERAND_PUNCT_VALID_P ++#define TARGET_PRINT_OPERAND_PUNCT_VALID_P \ ++ loongarch_print_operand_punct_valid_p ++ ++#undef TARGET_SETUP_INCOMING_VARARGS ++#define TARGET_SETUP_INCOMING_VARARGS loongarch_setup_incoming_varargs ++#undef TARGET_STRICT_ARGUMENT_NAMING ++#define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true ++#undef TARGET_MUST_PASS_IN_STACK ++#define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size ++#undef TARGET_PASS_BY_REFERENCE ++#define TARGET_PASS_BY_REFERENCE loongarch_pass_by_reference ++#undef TARGET_ARG_PARTIAL_BYTES ++#define TARGET_ARG_PARTIAL_BYTES loongarch_arg_partial_bytes ++#undef TARGET_FUNCTION_ARG ++#define TARGET_FUNCTION_ARG loongarch_function_arg ++#undef TARGET_FUNCTION_ARG_ADVANCE ++#define TARGET_FUNCTION_ARG_ADVANCE loongarch_function_arg_advance ++#undef TARGET_FUNCTION_ARG_BOUNDARY ++#define TARGET_FUNCTION_ARG_BOUNDARY loongarch_function_arg_boundary ++ ++#undef TARGET_VECTOR_MODE_SUPPORTED_P ++#define TARGET_VECTOR_MODE_SUPPORTED_P loongarch_vector_mode_supported_p ++ ++#undef TARGET_SCALAR_MODE_SUPPORTED_P ++#define TARGET_SCALAR_MODE_SUPPORTED_P loongarch_scalar_mode_supported_p ++ ++#undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE ++#define TARGET_VECTORIZE_PREFERRED_SIMD_MODE loongarch_preferred_simd_mode ++ ++#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES ++#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES \ ++ loongarch_autovectorize_vector_modes ++ ++#undef TARGET_INIT_BUILTINS + #define TARGET_INIT_BUILTINS loongarch_init_builtins + #undef TARGET_BUILTIN_DECL + #define TARGET_BUILTIN_DECL loongarch_builtin_decl +@@ -7006,6 +8886,14 @@ loongarch_set_handled_components (sbitmap components) + + #undef TARGET_MAX_ANCHOR_OFFSET + #define TARGET_MAX_ANCHOR_OFFSET (IMM_REACH/2-1) ++#undef TARGET_VECTORIZE_VEC_PERM_CONST ++#define TARGET_VECTORIZE_VEC_PERM_CONST loongarch_vectorize_vec_perm_const ++ ++#undef TARGET_SCHED_REASSOCIATION_WIDTH ++#define TARGET_SCHED_REASSOCIATION_WIDTH loongarch_sched_reassociation_width ++ ++#undef TARGET_CASE_VALUES_THRESHOLD ++#define TARGET_CASE_VALUES_THRESHOLD loongarch_case_values_threshold + + #undef TARGET_ATOMIC_ASSIGN_EXPAND_FENV + #define TARGET_ATOMIC_ASSIGN_EXPAND_FENV loongarch_atomic_assign_expand_fenv +@@ -7024,6 +8912,10 @@ loongarch_set_handled_components (sbitmap components) + #undef TARGET_MODES_TIEABLE_P + #define TARGET_MODES_TIEABLE_P loongarch_modes_tieable_p + ++#undef TARGET_HARD_REGNO_CALL_PART_CLOBBERED ++#define TARGET_HARD_REGNO_CALL_PART_CLOBBERED \ ++ loongarch_hard_regno_call_part_clobbered ++ + #undef TARGET_CUSTOM_FUNCTION_DESCRIPTORS + #define TARGET_CUSTOM_FUNCTION_DESCRIPTORS 2 + +@@ -7074,6 +8966,10 @@ loongarch_set_handled_components (sbitmap components) + #define TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS \ + loongarch_set_handled_components + ++#undef TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT ++#define TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT \ ++ loongarch_builtin_support_vector_misalignment ++ + struct gcc_target targetm = TARGET_INITIALIZER; + + #include "gt-loongarch.h" +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index e0c9c9439..c3ebea2f2 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -23,6 +23,8 @@ along with GCC; see the file COPYING3. If not see + + #include "config/loongarch/loongarch-opts.h" + ++#define TARGET_SUPPORTS_WIDE_INT 1 ++ + /* Macros to silence warnings about numbers being signed in traditional + C and unsigned in ISO C when compiled on 32-bit hosts. */ + +@@ -179,6 +181,11 @@ along with GCC; see the file COPYING3. If not see + #define MIN_UNITS_PER_WORD 4 + #endif + ++/* Width of a LSX vector register in bytes. */ ++#define UNITS_PER_LSX_REG 16 ++/* Width of a LSX vector register in bits. */ ++#define BITS_PER_LSX_REG (UNITS_PER_LSX_REG * BITS_PER_UNIT) ++ + /* For LARCH, width of a floating point register. */ + #define UNITS_PER_FPREG (TARGET_DOUBLE_FLOAT ? 8 : 4) + +@@ -241,8 +248,10 @@ along with GCC; see the file COPYING3. If not see + #define STRUCTURE_SIZE_BOUNDARY 8 + + /* There is no point aligning anything to a rounder boundary than +- LONG_DOUBLE_TYPE_SIZE. */ +-#define BIGGEST_ALIGNMENT (LONG_DOUBLE_TYPE_SIZE) ++ LONG_DOUBLE_TYPE_SIZE, unless under LSX the bigggest alignment is ++ BITS_PER_LSX_REG/.. */ ++#define BIGGEST_ALIGNMENT \ ++ (ISA_HAS_LSX ? BITS_PER_LSX_REG : LONG_DOUBLE_TYPE_SIZE) + + /* All accesses must be aligned. */ + #define STRICT_ALIGNMENT (TARGET_STRICT_ALIGN) +@@ -378,6 +387,9 @@ along with GCC; see the file COPYING3. If not see + #define FP_REG_FIRST 32 + #define FP_REG_LAST 63 + #define FP_REG_NUM (FP_REG_LAST - FP_REG_FIRST + 1) ++#define LSX_REG_FIRST FP_REG_FIRST ++#define LSX_REG_LAST FP_REG_LAST ++#define LSX_REG_NUM FP_REG_NUM + + /* The DWARF 2 CFA column which tracks the return address from a + signal handler context. This means that to maintain backwards +@@ -395,8 +407,11 @@ along with GCC; see the file COPYING3. If not see + ((unsigned int) ((int) (REGNO) - FP_REG_FIRST) < FP_REG_NUM) + #define FCC_REG_P(REGNO) \ + ((unsigned int) ((int) (REGNO) - FCC_REG_FIRST) < FCC_REG_NUM) ++#define LSX_REG_P(REGNO) \ ++ ((unsigned int) ((int) (REGNO) - LSX_REG_FIRST) < LSX_REG_NUM) + + #define FP_REG_RTX_P(X) (REG_P (X) && FP_REG_P (REGNO (X))) ++#define LSX_REG_RTX_P(X) (REG_P (X) && LSX_REG_P (REGNO (X))) + + /* Select a register mode required for caller save of hard regno REGNO. */ + #define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE) \ +@@ -577,6 +592,11 @@ enum reg_class + #define IMM12_OPERAND(VALUE) \ + ((unsigned HOST_WIDE_INT) (VALUE) + IMM_REACH / 2 < IMM_REACH) + ++/* True if VALUE is a signed 13-bit number. */ ++ ++#define IMM13_OPERAND(VALUE) \ ++ ((unsigned HOST_WIDE_INT) (VALUE) + 0x1000 < 0x2000) ++ + /* True if VALUE is a signed 16-bit number. */ + + #define IMM16_OPERAND(VALUE) \ +@@ -706,6 +726,13 @@ enum reg_class + #define FP_ARG_FIRST (FP_REG_FIRST + 0) + #define FP_ARG_LAST (FP_ARG_FIRST + MAX_ARGS_IN_REGISTERS - 1) + ++/* True if MODE is vector and supported in a LSX vector register. */ ++#define LSX_SUPPORTED_MODE_P(MODE) \ ++ (ISA_HAS_LSX \ ++ && GET_MODE_SIZE (MODE) == UNITS_PER_LSX_REG \ ++ && (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \ ++ || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)) ++ + /* 1 if N is a possible register number for function argument passing. + We have no FP argument registers when soft-float. */ + +@@ -926,7 +953,39 @@ typedef struct { + { "s7", 30 + GP_REG_FIRST }, \ + { "s8", 31 + GP_REG_FIRST }, \ + { "v0", 4 + GP_REG_FIRST }, \ +- { "v1", 5 + GP_REG_FIRST } \ ++ { "v1", 5 + GP_REG_FIRST }, \ ++ { "vr0", 0 + FP_REG_FIRST }, \ ++ { "vr1", 1 + FP_REG_FIRST }, \ ++ { "vr2", 2 + FP_REG_FIRST }, \ ++ { "vr3", 3 + FP_REG_FIRST }, \ ++ { "vr4", 4 + FP_REG_FIRST }, \ ++ { "vr5", 5 + FP_REG_FIRST }, \ ++ { "vr6", 6 + FP_REG_FIRST }, \ ++ { "vr7", 7 + FP_REG_FIRST }, \ ++ { "vr8", 8 + FP_REG_FIRST }, \ ++ { "vr9", 9 + FP_REG_FIRST }, \ ++ { "vr10", 10 + FP_REG_FIRST }, \ ++ { "vr11", 11 + FP_REG_FIRST }, \ ++ { "vr12", 12 + FP_REG_FIRST }, \ ++ { "vr13", 13 + FP_REG_FIRST }, \ ++ { "vr14", 14 + FP_REG_FIRST }, \ ++ { "vr15", 15 + FP_REG_FIRST }, \ ++ { "vr16", 16 + FP_REG_FIRST }, \ ++ { "vr17", 17 + FP_REG_FIRST }, \ ++ { "vr18", 18 + FP_REG_FIRST }, \ ++ { "vr19", 19 + FP_REG_FIRST }, \ ++ { "vr20", 20 + FP_REG_FIRST }, \ ++ { "vr21", 21 + FP_REG_FIRST }, \ ++ { "vr22", 22 + FP_REG_FIRST }, \ ++ { "vr23", 23 + FP_REG_FIRST }, \ ++ { "vr24", 24 + FP_REG_FIRST }, \ ++ { "vr25", 25 + FP_REG_FIRST }, \ ++ { "vr26", 26 + FP_REG_FIRST }, \ ++ { "vr27", 27 + FP_REG_FIRST }, \ ++ { "vr28", 28 + FP_REG_FIRST }, \ ++ { "vr29", 29 + FP_REG_FIRST }, \ ++ { "vr30", 30 + FP_REG_FIRST }, \ ++ { "vr31", 31 + FP_REG_FIRST } \ + } + + /* Globalizing directive for a label. */ +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 2d269794f..fb3828262 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -158,11 +158,12 @@ + const,signext,pick_ins,logical,arith,sll0,andi,shift_shift" + (const_string "unknown")) + +-(define_attr "alu_type" "unknown,add,sub,not,nor,and,or,xor" ++(define_attr "alu_type" "unknown,add,sub,not,nor,and,or,xor,simd_add" + (const_string "unknown")) + + ;; Main data type used by the insn +-(define_attr "mode" "unknown,none,QI,HI,SI,DI,TI,SF,DF,TF,FCC" ++(define_attr "mode" "unknown,none,QI,HI,SI,DI,TI,SF,DF,TF,FCC, ++ V2DI,V4SI,V8HI,V16QI,V2DF,V4SF" + (const_string "unknown")) + + ;; True if the main data type is twice the size of a word. +@@ -234,7 +235,12 @@ + prefetch,prefetchx,condmove,mgtf,mftg,const,arith,logical, + shift,slt,signext,clz,trap,imul,idiv,move, + fmove,fadd,fmul,fmadd,fdiv,frdiv,fabs,flogb,fneg,fcmp,fcopysign,fcvt, +- fscaleb,fsqrt,frsqrt,accext,accmod,multi,atomic,syncloop,nop,ghost" ++ fscaleb,fsqrt,frsqrt,accext,accmod,multi,atomic,syncloop,nop,ghost, ++ simd_div,simd_fclass,simd_flog2,simd_fadd,simd_fcvt,simd_fmul,simd_fmadd, ++ simd_fdiv,simd_bitins,simd_bitmov,simd_insert,simd_sld,simd_mul,simd_fcmp, ++ simd_fexp2,simd_int_arith,simd_bit,simd_shift,simd_splat,simd_fill, ++ simd_permute,simd_shf,simd_sat,simd_pcnt,simd_copy,simd_branch,simd_clsx, ++ simd_fminmax,simd_logic,simd_move,simd_load,simd_store" + (cond (eq_attr "jirl" "!unset") (const_string "call") + (eq_attr "got" "load") (const_string "load") + +@@ -414,11 +420,20 @@ + + ;; This attribute gives the upper-case mode name for one unit of a + ;; floating-point mode or vector mode. +-(define_mode_attr UNITMODE (SF "SF") (DF "DF")) ++(define_mode_attr UNITMODE (SF "SF") (DF "DF") (V2SF "SF") (V4SF "SF") ++ (V16QI "QI") (V8HI "HI") (V4SI "SI") (V2DI "DI") ++ (V2DF "DF")) ++ ++;; As above, but in lower case. ++(define_mode_attr unitmode (SF "sf") (DF "df") (V2SF "sf") (V4SF "sf") ++ (V16QI "qi") (V8QI "qi") (V8HI "hi") (V4HI "hi") ++ (V4SI "si") (V2SI "si") (V2DI "di") (V2DF "df")) + + ;; This attribute gives the integer mode that has half the size of + ;; the controlling mode. +-(define_mode_attr HALFMODE (DF "SI") (DI "SI") (TF "DI")) ++(define_mode_attr HALFMODE (DF "SI") (DI "SI") (V2SF "SI") ++ (V2SI "SI") (V4HI "SI") (V8QI "SI") ++ (TF "DI")) + + ;; This attribute gives the integer mode that has the same size of a + ;; floating-point mode. +@@ -445,6 +460,18 @@ + ;; from the same template. + (define_code_iterator any_div div udiv mod umod) + ++;; This code iterator allows addition and subtraction to be generated ++;; from the same template. ++(define_code_iterator addsub plus minus) ++ ++;; This code iterator allows addition and multiplication to be generated ++;; from the same template. ++(define_code_iterator addmul plus mult) ++ ++;; This code iterator allows addition subtraction and multiplication to be ++;; generated from the same template ++(define_code_iterator addsubmul plus minus mult) ++ + ;; This code iterator allows all native floating-point comparisons to be + ;; generated from the same template. + (define_code_iterator fcond unordered uneq unlt unle eq lt le +@@ -684,7 +711,6 @@ + (set_attr "alu_type" "sub") + (set_attr "mode" "<MODE>")) + +- + (define_insn "*subsi3_extended" + (set (match_operand:DI 0 "register_operand" "= r") + (sign_extend:DI +@@ -1228,7 +1254,7 @@ + "fmina.<fmt>\t%0,%1,%2" + (set_attr "type" "fmove") + (set_attr "mode" "<MODE>")) +- ++ + ;; + ;; .................... + ;; +@@ -2541,7 +2567,6 @@ + (set_attr "type" "shift,shift") + (set_attr "mode" "<MODE>")) + +- + ;; The following templates were added to generate "bstrpick.d + alsl.d" + ;; instruction pairs. + ;; It is required that the values of const_immalsl_operand and +@@ -3610,6 +3635,9 @@ + (include "generic.md") + (include "la464.md") + ++; The LoongArch SX Instructions. ++(include "lsx.md") ++ + (define_c_enum "unspec" + UNSPEC_ADDRESS_FIRST + ) +diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt +index f96d32769..8cc0c1d0b 100644 +--- a/gcc/config/loongarch/loongarch.opt ++++ b/gcc/config/loongarch/loongarch.opt +@@ -153,6 +153,10 @@ mbranch-cost= + Target RejectNegative Joined UInteger Var(loongarch_branch_cost) + -mbranch-cost=COST Set the cost of branches to roughly COST instructions. + ++mmemvec-cost= ++Target RejectNegative Joined UInteger Var(loongarch_vector_access_cost) IntegerRange(1, 5) ++mmemvec-cost=COST Set the cost of vector memory access instructions. ++ + mcheck-zero-division + Target Mask(CHECK_ZERO_DIV) + Trap on integer divide by zero. +diff --git a/gcc/config/loongarch/lsx.md b/gcc/config/loongarch/lsx.md +new file mode 100644 +index 000000000..fb4d228ba +--- /dev/null ++++ b/gcc/config/loongarch/lsx.md +@@ -0,0 +1,4467 @@ ++;; Machine Description for LARCH Loongson SX ASE ++;; ++;; Copyright (C) 2018 Free Software Foundation, Inc. ++;; ++;; This file is part of GCC. ++;; ++;; GCC is free software; you can redistribute it and/or modify ++;; it under the terms of the GNU General Public License as published by ++;; the Free Software Foundation; either version 3, or (at your option) ++;; any later version. ++;; ++;; GCC is distributed in the hope that it will be useful, ++;; but WITHOUT ANY WARRANTY; without even the implied warranty of ++;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++;; GNU General Public License for more details. ++;; ++;; You should have received a copy of the GNU General Public License ++;; along with GCC; see the file COPYING3. If not see ++;; <http://www.gnu.org/licenses/>. ++;; ++ ++(define_c_enum "unspec" ++ UNSPEC_LSX_ABSD_S ++ UNSPEC_LSX_VABSD_U ++ UNSPEC_LSX_VAVG_S ++ UNSPEC_LSX_VAVG_U ++ UNSPEC_LSX_VAVGR_S ++ UNSPEC_LSX_VAVGR_U ++ UNSPEC_LSX_VBITCLR ++ UNSPEC_LSX_VBITCLRI ++ UNSPEC_LSX_VBITREV ++ UNSPEC_LSX_VBITREVI ++ UNSPEC_LSX_VBITSET ++ UNSPEC_LSX_VBITSETI ++ UNSPEC_LSX_BRANCH_V ++ UNSPEC_LSX_BRANCH ++ UNSPEC_LSX_VFCMP_CAF ++ UNSPEC_LSX_VFCLASS ++ UNSPEC_LSX_VFCMP_CUNE ++ UNSPEC_LSX_VFCVT ++ UNSPEC_LSX_VFCVTH ++ UNSPEC_LSX_VFCVTL ++ UNSPEC_LSX_VFLOGB ++ UNSPEC_LSX_VFRECIP ++ UNSPEC_LSX_VFRINT ++ UNSPEC_LSX_VFRSQRT ++ UNSPEC_LSX_VFCMP_SAF ++ UNSPEC_LSX_VFCMP_SEQ ++ UNSPEC_LSX_VFCMP_SLE ++ UNSPEC_LSX_VFCMP_SLT ++ UNSPEC_LSX_VFCMP_SNE ++ UNSPEC_LSX_VFCMP_SOR ++ UNSPEC_LSX_VFCMP_SUEQ ++ UNSPEC_LSX_VFCMP_SULE ++ UNSPEC_LSX_VFCMP_SULT ++ UNSPEC_LSX_VFCMP_SUN ++ UNSPEC_LSX_VFCMP_SUNE ++ UNSPEC_LSX_VFTINT_S ++ UNSPEC_LSX_VFTINT_U ++ UNSPEC_LSX_VSAT_S ++ UNSPEC_LSX_VSAT_U ++ UNSPEC_LSX_VREPLVEI ++ UNSPEC_LSX_VSRAR ++ UNSPEC_LSX_VSRARI ++ UNSPEC_LSX_VSRLR ++ UNSPEC_LSX_VSRLRI ++ UNSPEC_LSX_VSHUF ++ UNSPEC_LSX_VMUH_S ++ UNSPEC_LSX_VMUH_U ++ UNSPEC_LSX_VEXTW_S ++ UNSPEC_LSX_VEXTW_U ++ UNSPEC_LSX_VSLLWIL_S ++ UNSPEC_LSX_VSLLWIL_U ++ UNSPEC_LSX_VSRAN ++ UNSPEC_LSX_VSSRAN_S ++ UNSPEC_LSX_VSSRAN_U ++ UNSPEC_LSX_VSRAIN ++ UNSPEC_LSX_VSRAINS_S ++ UNSPEC_LSX_VSRAINS_U ++ UNSPEC_LSX_VSRARN ++ UNSPEC_LSX_VSRLN ++ UNSPEC_LSX_VSRLRN ++ UNSPEC_LSX_VSSRLRN_U ++ UNSPEC_LSX_VFRSTPI ++ UNSPEC_LSX_VFRSTP ++ UNSPEC_LSX_VSHUF4I ++ UNSPEC_LSX_VBSRL_V ++ UNSPEC_LSX_VBSLL_V ++ UNSPEC_LSX_VEXTRINS ++ UNSPEC_LSX_VMSKLTZ ++ UNSPEC_LSX_VSIGNCOV ++ UNSPEC_LSX_VFTINTRNE ++ UNSPEC_LSX_VFTINTRP ++ UNSPEC_LSX_VFTINTRM ++ UNSPEC_LSX_VFTINT_W_D ++ UNSPEC_LSX_VFFINT_S_L ++ UNSPEC_LSX_VFTINTRZ_W_D ++ UNSPEC_LSX_VFTINTRP_W_D ++ UNSPEC_LSX_VFTINTRM_W_D ++ UNSPEC_LSX_VFTINTRNE_W_D ++ UNSPEC_LSX_VFTINTL_L_S ++ UNSPEC_LSX_VFFINTH_D_W ++ UNSPEC_LSX_VFFINTL_D_W ++ UNSPEC_LSX_VFTINTRZL_L_S ++ UNSPEC_LSX_VFTINTRZH_L_S ++ UNSPEC_LSX_VFTINTRPL_L_S ++ UNSPEC_LSX_VFTINTRPH_L_S ++ UNSPEC_LSX_VFTINTRMH_L_S ++ UNSPEC_LSX_VFTINTRML_L_S ++ UNSPEC_LSX_VFTINTRNEL_L_S ++ UNSPEC_LSX_VFTINTRNEH_L_S ++ UNSPEC_LSX_VFTINTH_L_H ++ UNSPEC_LSX_VFRINTRNE_S ++ UNSPEC_LSX_VFRINTRNE_D ++ UNSPEC_LSX_VFRINTRZ_S ++ UNSPEC_LSX_VFRINTRZ_D ++ UNSPEC_LSX_VFRINTRP_S ++ UNSPEC_LSX_VFRINTRP_D ++ UNSPEC_LSX_VFRINTRM_S ++ UNSPEC_LSX_VFRINTRM_D ++ UNSPEC_LSX_VSSRARN_S ++ UNSPEC_LSX_VSSRARN_U ++ UNSPEC_LSX_VSSRLN_U ++ UNSPEC_LSX_VSSRLN ++ UNSPEC_LSX_VSSRLRN ++ UNSPEC_LSX_VLDI ++ UNSPEC_LSX_VSHUF_B ++ UNSPEC_LSX_VLDX ++ UNSPEC_LSX_VSTX ++ UNSPEC_LSX_VEXTL_QU_DU ++ UNSPEC_LSX_VSETEQZ_V ++ UNSPEC_LSX_VADDWEV ++ UNSPEC_LSX_VADDWEV2 ++ UNSPEC_LSX_VADDWEV3 ++ UNSPEC_LSX_VADDWOD ++ UNSPEC_LSX_VADDWOD2 ++ UNSPEC_LSX_VADDWOD3 ++ UNSPEC_LSX_VSUBWEV ++ UNSPEC_LSX_VSUBWEV2 ++ UNSPEC_LSX_VSUBWOD ++ UNSPEC_LSX_VSUBWOD2 ++ UNSPEC_LSX_VMULWEV ++ UNSPEC_LSX_VMULWEV2 ++ UNSPEC_LSX_VMULWEV3 ++ UNSPEC_LSX_VMULWOD ++ UNSPEC_LSX_VMULWOD2 ++ UNSPEC_LSX_VMULWOD3 ++ UNSPEC_LSX_VHADDW_Q_D ++ UNSPEC_LSX_VHADDW_QU_DU ++ UNSPEC_LSX_VHSUBW_Q_D ++ UNSPEC_LSX_VHSUBW_QU_DU ++ UNSPEC_LSX_VMADDWEV ++ UNSPEC_LSX_VMADDWEV2 ++ UNSPEC_LSX_VMADDWEV3 ++ UNSPEC_LSX_VMADDWOD ++ UNSPEC_LSX_VMADDWOD2 ++ UNSPEC_LSX_VMADDWOD3 ++ UNSPEC_LSX_VROTR ++ UNSPEC_LSX_VADD_Q ++ UNSPEC_LSX_VSUB_Q ++ UNSPEC_LSX_VEXTH_Q_D ++ UNSPEC_LSX_VEXTH_QU_DU ++ UNSPEC_LSX_VMSKGEZ ++ UNSPEC_LSX_VMSKNZ ++ UNSPEC_LSX_VEXTL_Q_D ++ UNSPEC_LSX_VSRLNI ++ UNSPEC_LSX_VSRLRNI ++ UNSPEC_LSX_VSSRLNI ++ UNSPEC_LSX_VSSRLNI2 ++ UNSPEC_LSX_VSSRLRNI ++ UNSPEC_LSX_VSSRLRNI2 ++ UNSPEC_LSX_VSRANI ++ UNSPEC_LSX_VSRARNI ++ UNSPEC_LSX_VSSRANI ++ UNSPEC_LSX_VSSRANI2 ++ UNSPEC_LSX_VSSRARNI ++ UNSPEC_LSX_VSSRARNI2 ++ UNSPEC_LSX_VPERMI ++) ++ ++;; This attribute gives suffix for integers in VHMODE. ++(define_mode_attr dlsxfmt ++ (V2DI "q") ++ (V4SI "d") ++ (V8HI "w") ++ (V16QI "h")) ++ ++(define_mode_attr dlsxfmt_u ++ (V2DI "qu") ++ (V4SI "du") ++ (V8HI "wu") ++ (V16QI "hu")) ++ ++(define_mode_attr d2lsxfmt ++ (V4SI "q") ++ (V8HI "d") ++ (V16QI "w")) ++ ++(define_mode_attr d2lsxfmt_u ++ (V4SI "qu") ++ (V8HI "du") ++ (V16QI "wu")) ++ ++;; The attribute gives two double modes for vector modes. ++(define_mode_attr VD2MODE ++ (V4SI "V2DI") ++ (V8HI "V2DI") ++ (V16QI "V4SI")) ++ ++;; All vector modes with 128 bits. ++(define_mode_iterator LSX V2DF V4SF V2DI V4SI V8HI V16QI) ++ ++;; Same as LSX. Used by vcond to iterate two modes. ++(define_mode_iterator LSX_2 V2DF V4SF V2DI V4SI V8HI V16QI) ++ ++;; Only used for vilvh and splitting insert_d and copy_{u,s}.d. ++(define_mode_iterator LSX_D V2DI V2DF) ++ ++;; Only used for copy_{u,s}.w and vilvh. ++(define_mode_iterator LSX_W V4SI V4SF) ++ ++;; Only integer modes. ++(define_mode_iterator ILSX V2DI V4SI V8HI V16QI) ++ ++;; As ILSX but excludes V16QI. ++(define_mode_iterator ILSX_DWH V2DI V4SI V8HI) ++ ++;; As LSX but excludes V16QI. ++(define_mode_iterator LSX_DWH V2DF V4SF V2DI V4SI V8HI) ++ ++;; As ILSX but excludes V2DI. ++(define_mode_iterator ILSX_WHB V4SI V8HI V16QI) ++ ++;; Only integer modes equal or larger than a word. ++(define_mode_iterator ILSX_DW V2DI V4SI) ++ ++;; Only integer modes smaller than a word. ++(define_mode_iterator ILSX_HB V8HI V16QI) ++ ++;;;; Only integer modes for fixed-point madd_q/maddr_q. ++;;(define_mode_iterator ILSX_WH V4SI V8HI) ++ ++;; Only floating-point modes. ++(define_mode_iterator FLSX V2DF V4SF) ++ ++;; Only used for immediate set shuffle elements instruction. ++(define_mode_iterator LSX_WHB_W V4SI V8HI V16QI V4SF) ++ ++;; The attribute gives the integer vector mode with same size. ++(define_mode_attr VIMODE ++ (V2DF "V2DI") ++ (V4SF "V4SI") ++ (V2DI "V2DI") ++ (V4SI "V4SI") ++ (V8HI "V8HI") ++ (V16QI "V16QI")) ++ ++;; The attribute gives half modes for vector modes. ++(define_mode_attr VHMODE ++ (V8HI "V16QI") ++ (V4SI "V8HI") ++ (V2DI "V4SI")) ++ ++;; The attribute gives double modes for vector modes. ++(define_mode_attr VDMODE ++ (V2DI "V2DI") ++ (V4SI "V2DI") ++ (V8HI "V4SI") ++ (V16QI "V8HI")) ++ ++;; The attribute gives half modes with same number of elements for vector modes. ++(define_mode_attr VTRUNCMODE ++ (V8HI "V8QI") ++ (V4SI "V4HI") ++ (V2DI "V2SI")) ++ ++;; Double-sized Vector MODE with same elemet type. "Vector, Enlarged-MODE" ++(define_mode_attr VEMODE ++ (V4SF "V8SF") ++ (V4SI "V8SI") ++ (V2DI "V4DI") ++ (V2DF "V4DF")) ++ ++;; This attribute gives the mode of the result for "vpickve2gr_b, copy_u_b" etc. ++(define_mode_attr VRES ++ (V2DF "DF") ++ (V4SF "SF") ++ (V2DI "DI") ++ (V4SI "SI") ++ (V8HI "SI") ++ (V16QI "SI")) ++ ++;; Only used with LSX_D iterator. ++(define_mode_attr lsx_d ++ (V2DI "reg_or_0") ++ (V2DF "register")) ++ ++;; This attribute gives the integer vector mode with same size. ++(define_mode_attr mode_i ++ (V2DF "v2di") ++ (V4SF "v4si") ++ (V2DI "v2di") ++ (V4SI "v4si") ++ (V8HI "v8hi") ++ (V16QI "v16qi")) ++ ++;; This attribute gives suffix for LSX instructions. ++(define_mode_attr lsxfmt ++ (V2DF "d") ++ (V4SF "w") ++ (V2DI "d") ++ (V4SI "w") ++ (V8HI "h") ++ (V16QI "b")) ++ ++;; This attribute gives suffix for LSX instructions. ++(define_mode_attr lsxfmt_u ++ (V2DF "du") ++ (V4SF "wu") ++ (V2DI "du") ++ (V4SI "wu") ++ (V8HI "hu") ++ (V16QI "bu")) ++ ++;; This attribute gives suffix for integers in VHMODE. ++(define_mode_attr hlsxfmt ++ (V2DI "w") ++ (V4SI "h") ++ (V8HI "b")) ++ ++;; This attribute gives suffix for integers in VHMODE. ++(define_mode_attr hlsxfmt_u ++ (V2DI "wu") ++ (V4SI "hu") ++ (V8HI "bu")) ++ ++;; This attribute gives define_insn suffix for LSX instructions that need ++;; distinction between integer and floating point. ++(define_mode_attr lsxfmt_f ++ (V2DF "d_f") ++ (V4SF "w_f") ++ (V2DI "d") ++ (V4SI "w") ++ (V8HI "h") ++ (V16QI "b")) ++ ++(define_mode_attr flsxfmt_f ++ (V2DF "d_f") ++ (V4SF "s_f") ++ (V2DI "d") ++ (V4SI "w") ++ (V8HI "h") ++ (V16QI "b")) ++ ++(define_mode_attr flsxfmt ++ (V2DF "d") ++ (V4SF "s") ++ (V2DI "d") ++ (V4SI "s")) ++ ++(define_mode_attr flsxfrint ++ (V2DF "d") ++ (V4SF "s")) ++ ++(define_mode_attr ilsxfmt ++ (V2DF "l") ++ (V4SF "w")) ++ ++(define_mode_attr ilsxfmt_u ++ (V2DF "lu") ++ (V4SF "wu")) ++ ++;; This is used to form an immediate operand constraint using ++;; "const_<indeximm>_operand". ++(define_mode_attr indeximm ++ (V2DF "0_or_1") ++ (V4SF "0_to_3") ++ (V2DI "0_or_1") ++ (V4SI "0_to_3") ++ (V8HI "uimm3") ++ (V16QI "uimm4")) ++ ++;; This attribute represents bitmask needed for vec_merge using ++;; "const_<bitmask>_operand". ++(define_mode_attr bitmask ++ (V2DF "exp_2") ++ (V4SF "exp_4") ++ (V2DI "exp_2") ++ (V4SI "exp_4") ++ (V8HI "exp_8") ++ (V16QI "exp_16")) ++ ++;; This attribute is used to form an immediate operand constraint using ++;; "const_<bitimm>_operand". ++(define_mode_attr bitimm ++ (V16QI "uimm3") ++ (V8HI "uimm4") ++ (V4SI "uimm5") ++ (V2DI "uimm6")) ++ ++ ++(define_int_iterator FRINT_S UNSPEC_LSX_VFRINTRP_S ++ UNSPEC_LSX_VFRINTRZ_S ++ UNSPEC_LSX_VFRINT ++ UNSPEC_LSX_VFRINTRM_S) ++ ++(define_int_iterator FRINT_D UNSPEC_LSX_VFRINTRP_D ++ UNSPEC_LSX_VFRINTRZ_D ++ UNSPEC_LSX_VFRINT ++ UNSPEC_LSX_VFRINTRM_D) ++ ++(define_int_attr frint_pattern_s ++ (UNSPEC_LSX_VFRINTRP_S "ceil") ++ (UNSPEC_LSX_VFRINTRZ_S "btrunc") ++ (UNSPEC_LSX_VFRINT "rint") ++ (UNSPEC_LSX_VFRINTRM_S "floor")) ++ ++(define_int_attr frint_pattern_d ++ (UNSPEC_LSX_VFRINTRP_D "ceil") ++ (UNSPEC_LSX_VFRINTRZ_D "btrunc") ++ (UNSPEC_LSX_VFRINT "rint") ++ (UNSPEC_LSX_VFRINTRM_D "floor")) ++ ++(define_int_attr frint_suffix ++ (UNSPEC_LSX_VFRINTRP_S "rp") ++ (UNSPEC_LSX_VFRINTRP_D "rp") ++ (UNSPEC_LSX_VFRINTRZ_S "rz") ++ (UNSPEC_LSX_VFRINTRZ_D "rz") ++ (UNSPEC_LSX_VFRINT "") ++ (UNSPEC_LSX_VFRINTRM_S "rm") ++ (UNSPEC_LSX_VFRINTRM_D "rm")) ++ ++(define_expand "vec_init<mode><unitmode>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand:LSX 1 "") ++ "ISA_HAS_LSX" ++{ ++ loongarch_expand_vector_init (operands0, operands1); ++ DONE; ++}) ++ ++;; vpickev pattern with implicit type conversion. ++(define_insn "vec_pack_trunc_<mode>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (vec_concat:<VHMODE> ++ (truncate:<VTRUNCMODE> ++ (match_operand:ILSX_DWH 1 "register_operand" "f")) ++ (truncate:<VTRUNCMODE> ++ (match_operand:ILSX_DWH 2 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vpickev.<hlsxfmt>\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "<MODE>")) ++ ++(define_expand "vec_unpacks_hi_v4sf" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (float_extend:V2DF ++ (vec_select:V2SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (match_dup 2)))) ++ "ISA_HAS_LSX" ++{ ++ operands2 = loongarch_lsx_vec_parallel_const_half (V4SFmode, ++ true/*high_p*/); ++}) ++ ++(define_expand "vec_unpacks_lo_v4sf" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (float_extend:V2DF ++ (vec_select:V2SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (match_dup 2)))) ++ "ISA_HAS_LSX" ++{ ++ operands2 = loongarch_lsx_vec_parallel_const_half (V4SFmode, ++ false/*high_p*/); ++}) ++ ++(define_expand "vec_unpacks_hi_<mode>" ++ (match_operand:<VDMODE> 0 "register_operand") ++ (match_operand:ILSX_WHB 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ loongarch_expand_vec_unpack (operands, false/*unsigned_p*/, true/*high_p*/); ++ DONE; ++}) ++ ++(define_expand "vec_unpacks_lo_<mode>" ++ (match_operand:<VDMODE> 0 "register_operand") ++ (match_operand:ILSX_WHB 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ loongarch_expand_vec_unpack (operands, false/*unsigned_p*/, false/*high_p*/); ++ DONE; ++}) ++ ++(define_expand "vec_unpacku_hi_<mode>" ++ (match_operand:<VDMODE> 0 "register_operand") ++ (match_operand:ILSX_WHB 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ loongarch_expand_vec_unpack (operands, true/*unsigned_p*/, true/*high_p*/); ++ DONE; ++}) ++ ++(define_expand "vec_unpacku_lo_<mode>" ++ (match_operand:<VDMODE> 0 "register_operand") ++ (match_operand:ILSX_WHB 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ loongarch_expand_vec_unpack (operands, true/*unsigned_p*/, false/*high_p*/); ++ DONE; ++}) ++ ++(define_expand "vec_extract<mode><unitmode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:ILSX 1 "register_operand") ++ (match_operand 2 "const_<indeximm>_operand") ++ "ISA_HAS_LSX" ++{ ++ if (<UNITMODE>mode == QImode || <UNITMODE>mode == HImode) ++ { ++ rtx dest1 = gen_reg_rtx (SImode); ++ emit_insn (gen_lsx_vpickve2gr_<lsxfmt> (dest1, operands1, operands2)); ++ emit_move_insn (operands0, ++ gen_lowpart (<UNITMODE>mode, dest1)); ++ } ++ else ++ emit_insn (gen_lsx_vpickve2gr_<lsxfmt> (operands0, operands1, operands2)); ++ DONE; ++}) ++ ++(define_expand "vec_extract<mode><unitmode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:FLSX 1 "register_operand") ++ (match_operand 2 "const_<indeximm>_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx temp; ++ HOST_WIDE_INT val = INTVAL (operands2); ++ ++ if (val == 0) ++ temp = operands1; ++ else ++ { ++ rtx n = GEN_INT (val * GET_MODE_SIZE (<UNITMODE>mode)); ++ temp = gen_reg_rtx (<MODE>mode); ++ emit_insn (gen_lsx_vbsrl_<lsxfmt_f> (temp, operands1, n)); ++ } ++ emit_insn (gen_lsx_vec_extract_<lsxfmt_f> (operands0, temp)); ++ DONE; ++}) ++ ++(define_insn_and_split "lsx_vec_extract_<lsxfmt_f>" ++ (set (match_operand:<UNITMODE> 0 "register_operand" "=f") ++ (vec_select:<UNITMODE> ++ (match_operand:FLSX 1 "register_operand" "f") ++ (parallel (const_int 0)))) ++ "ISA_HAS_LSX" ++ "#" ++ "&& reload_completed" ++ (set (match_dup 0) (match_dup 1)) ++{ ++ operands1 = gen_rtx_REG (<UNITMODE>mode, REGNO (operands1)); ++} ++ (set_attr "move_type" "fmove") ++ (set_attr "mode" "<UNITMODE>")) ++ ++(define_expand "vec_set<mode>" ++ (match_operand:ILSX 0 "register_operand") ++ (match_operand:<UNITMODE> 1 "reg_or_0_operand") ++ (match_operand 2 "const_<indeximm>_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx index = GEN_INT (1 << INTVAL (operands2)); ++ emit_insn (gen_lsx_vinsgr2vr_<lsxfmt> (operands0, operands1, ++ operands0, index)); ++ DONE; ++}) ++ ++(define_expand "vec_set<mode>" ++ (match_operand:FLSX 0 "register_operand") ++ (match_operand:<UNITMODE> 1 "register_operand") ++ (match_operand 2 "const_<indeximm>_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx index = GEN_INT (1 << INTVAL (operands2)); ++ emit_insn (gen_lsx_vextrins_<lsxfmt_f>_scalar (operands0, operands1, ++ operands0, index)); ++ DONE; ++}) ++ ++(define_expand "vec_cmp<mode><mode_i>" ++ (set (match_operand:<VIMODE> 0 "register_operand") ++ (match_operator 1 "" ++ (match_operand:LSX 2 "register_operand") ++ (match_operand:LSX 3 "register_operand"))) ++ "ISA_HAS_LSX" ++{ ++ bool ok = loongarch_expand_vec_cmp (operands); ++ gcc_assert (ok); ++ DONE; ++}) ++ ++(define_expand "vec_cmpu<ILSX:mode><mode_i>" ++ (set (match_operand:<VIMODE> 0 "register_operand") ++ (match_operator 1 "" ++ (match_operand:ILSX 2 "register_operand") ++ (match_operand:ILSX 3 "register_operand"))) ++ "ISA_HAS_LSX" ++{ ++ bool ok = loongarch_expand_vec_cmp (operands); ++ gcc_assert (ok); ++ DONE; ++}) ++ ++(define_expand "vcondu<LSX:mode><ILSX:mode>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand:LSX 1 "reg_or_m1_operand") ++ (match_operand:LSX 2 "reg_or_0_operand") ++ (match_operator 3 "" ++ (match_operand:ILSX 4 "register_operand") ++ (match_operand:ILSX 5 "register_operand")) ++ "ISA_HAS_LSX ++ && (GET_MODE_NUNITS (<LSX:MODE>mode) == GET_MODE_NUNITS (<ILSX:MODE>mode))" ++{ ++ loongarch_expand_vec_cond_expr (<LSX:MODE>mode, <LSX:VIMODE>mode, operands); ++ DONE; ++}) ++ ++(define_expand "vcond<LSX:mode><LSX_2:mode>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand:LSX 1 "reg_or_m1_operand") ++ (match_operand:LSX 2 "reg_or_0_operand") ++ (match_operator 3 "" ++ (match_operand:LSX_2 4 "register_operand") ++ (match_operand:LSX_2 5 "register_operand")) ++ "ISA_HAS_LSX ++ && (GET_MODE_NUNITS (<LSX:MODE>mode) == GET_MODE_NUNITS (<LSX_2:MODE>mode))" ++{ ++ loongarch_expand_vec_cond_expr (<LSX:MODE>mode, <LSX:VIMODE>mode, operands); ++ DONE; ++}) ++ ++(define_expand "vcond_mask_<ILSX:mode><ILSX:mode>" ++ (match_operand:ILSX 0 "register_operand") ++ (match_operand:ILSX 1 "reg_or_m1_operand") ++ (match_operand:ILSX 2 "reg_or_0_operand") ++ (match_operand:ILSX 3 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ loongarch_expand_vec_cond_mask_expr (<ILSX:MODE>mode, ++ <ILSX:VIMODE>mode, operands); ++ DONE; ++}) ++ ++(define_insn "lsx_vinsgr2vr_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (vec_merge:ILSX ++ (vec_duplicate:ILSX ++ (match_operand:<UNITMODE> 1 "reg_or_0_operand" "rJ")) ++ (match_operand:ILSX 2 "register_operand" "0") ++ (match_operand 3 "const_<bitmask>_operand" ""))) ++ "ISA_HAS_LSX" ++{ ++ if (!TARGET_64BIT && (<MODE>mode == V2DImode || <MODE>mode == V2DFmode)) ++ return "#"; ++ else ++ return "vinsgr2vr.<lsxfmt>\t%w0,%z1,%y3"; ++} ++ (set_attr "type" "simd_insert") ++ (set_attr "mode" "<MODE>")) ++ ++(define_split ++ (set (match_operand:LSX_D 0 "register_operand") ++ (vec_merge:LSX_D ++ (vec_duplicate:LSX_D ++ (match_operand:<UNITMODE> 1 "<LSX_D:lsx_d>_operand")) ++ (match_operand:LSX_D 2 "register_operand") ++ (match_operand 3 "const_<bitmask>_operand"))) ++ "reload_completed && ISA_HAS_LSX && !TARGET_64BIT" ++ (const_int 0) ++{ ++ loongarch_split_lsx_insert_d (operands0, operands2, operands3, operands1); ++ DONE; ++}) ++ ++(define_insn "lsx_vextrins_<lsxfmt_f>_internal" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (vec_merge:LSX ++ (vec_duplicate:LSX ++ (vec_select:<UNITMODE> ++ (match_operand:LSX 1 "register_operand" "f") ++ (parallel (const_int 0)))) ++ (match_operand:LSX 2 "register_operand" "0") ++ (match_operand 3 "const_<bitmask>_operand" ""))) ++ "ISA_HAS_LSX" ++ "vextrins.<lsxfmt>\t%w0,%w1,%y3<<4" ++ (set_attr "type" "simd_insert") ++ (set_attr "mode" "<MODE>")) ++ ++;; Operand 3 is a scalar. ++(define_insn "lsx_vextrins_<lsxfmt_f>_scalar" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (vec_merge:FLSX ++ (vec_duplicate:FLSX ++ (match_operand:<UNITMODE> 1 "register_operand" "f")) ++ (match_operand:FLSX 2 "register_operand" "0") ++ (match_operand 3 "const_<bitmask>_operand" ""))) ++ "ISA_HAS_LSX" ++ "vextrins.<lsxfmt>\t%w0,%w1,%y3<<4" ++ (set_attr "type" "simd_insert") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vpickve2gr_<lsxfmt><u>" ++ (set (match_operand:<VRES> 0 "register_operand" "=r") ++ (any_extend:<VRES> ++ (vec_select:<UNITMODE> ++ (match_operand:ILSX_HB 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_<indeximm>_operand" ""))))) ++ "ISA_HAS_LSX" ++ "vpickve2gr.<lsxfmt><u>\t%0,%w1,%2" ++ (set_attr "type" "simd_copy") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vpickve2gr_<lsxfmt_f><u>" ++ (set (match_operand:<UNITMODE> 0 "register_operand" "=r") ++ (any_extend:<UNITMODE> ++ (vec_select:<UNITMODE> ++ (match_operand:LSX_W 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_<indeximm>_operand" ""))))) ++ "ISA_HAS_LSX" ++ "vpickve2gr.<lsxfmt><u>\t%0,%w1,%2" ++ (set_attr "type" "simd_copy") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn_and_split "lsx_vpickve2gr_du" ++ (set (match_operand:DI 0 "register_operand" "=r") ++ (vec_select:DI ++ (match_operand:V2DI 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_0_or_1_operand" "")))) ++ "ISA_HAS_LSX" ++{ ++ if (TARGET_64BIT) ++ return "vpickve2gr.du\t%0,%w1,%2"; ++ else ++ return "#"; ++} ++ "reload_completed && ISA_HAS_LSX && !TARGET_64BIT" ++ (const_int 0) ++{ ++ loongarch_split_lsx_copy_d (operands0, operands1, operands2, ++ gen_lsx_vpickve2gr_wu); ++ DONE; ++} ++ (set_attr "type" "simd_copy") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn_and_split "lsx_vpickve2gr_<lsxfmt_f>" ++ (set (match_operand:<UNITMODE> 0 "register_operand" "=r") ++ (vec_select:<UNITMODE> ++ (match_operand:LSX_D 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_<indeximm>_operand" "")))) ++ "ISA_HAS_LSX" ++{ ++ if (TARGET_64BIT) ++ return "vpickve2gr.<lsxfmt>\t%0,%w1,%2"; ++ else ++ return "#"; ++} ++ "reload_completed && ISA_HAS_LSX && !TARGET_64BIT" ++ (const_int 0) ++{ ++ loongarch_split_lsx_copy_d (operands0, operands1, operands2, ++ gen_lsx_vpickve2gr_w); ++ DONE; ++} ++ (set_attr "type" "simd_copy") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_expand "abs<mode>2" ++ (match_operand:ILSX 0 "register_operand" "=f") ++ (abs:ILSX (match_operand:ILSX 1 "register_operand" "f")) ++ "ISA_HAS_LSX" ++{ ++ if (ISA_HAS_LSX) ++ { ++ emit_insn (gen_vabs<mode>2 (operands0, operands1)); ++ DONE; ++ } ++ else ++ { ++ rtx reg = gen_reg_rtx (<MODE>mode); ++ emit_move_insn (reg, CONST0_RTX (<MODE>mode)); ++ emit_insn (gen_lsx_vadda_<lsxfmt> (operands0, operands1, reg)); ++ DONE; ++ } ++}) ++ ++(define_expand "neg<mode>2" ++ (set (match_operand:ILSX 0 "register_operand") ++ (neg:ILSX (match_operand:ILSX 1 "register_operand"))) ++ "ISA_HAS_LSX" ++{ ++ emit_insn (gen_vneg<mode>2 (operands0, operands1)); ++ DONE; ++}) ++ ++(define_expand "neg<mode>2" ++ (set (match_operand:FLSX 0 "register_operand") ++ (neg:FLSX (match_operand:FLSX 1 "register_operand"))) ++ "ISA_HAS_LSX" ++{ ++ rtx reg = gen_reg_rtx (<MODE>mode); ++ emit_move_insn (reg, CONST0_RTX (<MODE>mode)); ++ emit_insn (gen_sub<mode>3 (operands0, reg, operands1)); ++ DONE; ++}) ++ ++(define_expand "lsx_vrepli<mode>" ++ (match_operand:ILSX 0 "register_operand") ++ (match_operand 1 "const_imm10_operand") ++ "ISA_HAS_LSX" ++{ ++ if (<MODE>mode == V16QImode) ++ operands1 = GEN_INT (trunc_int_for_mode (INTVAL (operands1), ++ <UNITMODE>mode)); ++ emit_move_insn (operands0, ++ loongarch_gen_const_int_vector (<MODE>mode, INTVAL (operands1))); ++ DONE; ++}) ++ ++(define_expand "vec_perm<mode>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand:LSX 1 "register_operand") ++ (match_operand:LSX 2 "register_operand") ++ (match_operand:LSX 3 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ loongarch_expand_vec_perm (operands0, operands1, ++ operands2, operands3); ++ DONE; ++}) ++ ++(define_insn "lsx_vshuf_<lsxfmt_f>" ++ (set (match_operand:LSX_DWH 0 "register_operand" "=f") ++ (unspec:LSX_DWH (match_operand:LSX_DWH 1 "register_operand" "0") ++ (match_operand:LSX_DWH 2 "register_operand" "f") ++ (match_operand:LSX_DWH 3 "register_operand" "f") ++ UNSPEC_LSX_VSHUF)) ++ "ISA_HAS_LSX" ++ "vshuf.<lsxfmt>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_sld") ++ (set_attr "mode" "<MODE>")) ++ ++(define_expand "mov<mode>" ++ (set (match_operand:LSX 0) ++ (match_operand:LSX 1)) ++ "ISA_HAS_LSX" ++{ ++ if (loongarch_legitimize_move (<MODE>mode, operands0, operands1)) ++ DONE; ++}) ++ ++(define_expand "movmisalign<mode>" ++ (set (match_operand:LSX 0) ++ (match_operand:LSX 1)) ++ "ISA_HAS_LSX" ++{ ++ if (loongarch_legitimize_move (<MODE>mode, operands0, operands1)) ++ DONE; ++}) ++ ++(define_insn "mov<mode>_lsx" ++ (set (match_operand:LSX 0 "nonimmediate_operand" "=f,f,R,*r,*f") ++ (match_operand:LSX 1 "move_operand" "fYGYI,R,f,*f,*r")) ++ "ISA_HAS_LSX" ++{ return loongarch_output_move (operands0, operands1); } ++ (set_attr "type" "simd_move,simd_load,simd_store,simd_copy,simd_insert") ++ (set_attr "mode" "<MODE>")) ++ ++(define_split ++ (set (match_operand:LSX 0 "nonimmediate_operand") ++ (match_operand:LSX 1 "move_operand")) ++ "reload_completed && ISA_HAS_LSX ++ && loongarch_split_move_insn_p (operands0, operands1)" ++ (const_int 0) ++{ ++ loongarch_split_move_insn (operands0, operands1, curr_insn); ++ DONE; ++}) ++ ++;; Offset load ++(define_expand "lsx_ld_<lsxfmt_f>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq10<lsxfmt>_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (operands0, gen_rtx_MEM (<MODE>mode, addr)); ++ DONE; ++}) ++ ++;; Offset store ++(define_expand "lsx_st_<lsxfmt_f>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq10<lsxfmt>_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (gen_rtx_MEM (<MODE>mode, addr), operands0); ++ DONE; ++}) ++ ++;; Integer operations ++(define_insn "add<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f,f") ++ (plus:ILSX ++ (match_operand:ILSX 1 "register_operand" "f,f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_ximm5_operand" "f,Unv5,Uuv5"))) ++ "ISA_HAS_LSX" ++{ ++ switch (which_alternative) ++ { ++ case 0: ++ return "vadd.<lsxfmt>\t%w0,%w1,%w2"; ++ case 1: ++ { ++ HOST_WIDE_INT val = INTVAL (CONST_VECTOR_ELT (operands2, 0)); ++ ++ operands2 = GEN_INT (-val); ++ return "vsubi.<lsxfmt_u>\t%w0,%w1,%d2"; ++ } ++ case 2: ++ return "vaddi.<lsxfmt_u>\t%w0,%w1,%E2"; ++ default: ++ gcc_unreachable (); ++ } ++} ++ (set_attr "alu_type" "simd_add") ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "sub<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (minus:ILSX ++ (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_uimm5_operand" "f,Uuv5"))) ++ "ISA_HAS_LSX" ++ "@ ++ vsub.<lsxfmt>\t%w0,%w1,%w2 ++ vsubi.<lsxfmt_u>\t%w0,%w1,%E2" ++ (set_attr "alu_type" "simd_add") ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "mul<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (mult:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vmul.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_mul") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vmadd_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (plus:ILSX (mult:ILSX (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand:ILSX 3 "register_operand" "f")) ++ (match_operand:ILSX 1 "register_operand" "0"))) ++ "ISA_HAS_LSX" ++ "vmadd.<lsxfmt>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_mul") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vmsub_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (minus:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (mult:ILSX (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand:ILSX 3 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vmsub.<lsxfmt>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_mul") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "div<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (div:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++{ return loongarch_lsx_output_division ("vdiv.<lsxfmt>\t%w0,%w1,%w2", operands); } ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "udiv<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (udiv:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++{ return loongarch_lsx_output_division ("vdiv.<lsxfmt_u>\t%w0,%w1,%w2", operands); } ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "mod<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (mod:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++{ return loongarch_lsx_output_division ("vmod.<lsxfmt>\t%w0,%w1,%w2", operands); } ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "umod<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (umod:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++{ return loongarch_lsx_output_division ("vmod.<lsxfmt_u>\t%w0,%w1,%w2", operands); } ++ (set_attr "type" "simd_div") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "xor<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f,f") ++ (xor:ILSX ++ (match_operand:ILSX 1 "register_operand" "f,f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_val_operand" "f,YC,Urv8"))) ++ "ISA_HAS_LSX" ++ "@ ++ vxor.v\t%w0,%w1,%w2 ++ vbitrevi.%v0\t%w0,%w1,%V2 ++ vxori.b\t%w0,%w1,%B2" ++ (set_attr "type" "simd_logic,simd_bit,simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "ior<mode>3" ++ (set (match_operand:LSX 0 "register_operand" "=f,f,f") ++ (ior:LSX ++ (match_operand:LSX 1 "register_operand" "f,f,f") ++ (match_operand:LSX 2 "reg_or_vector_same_val_operand" "f,YC,Urv8"))) ++ "ISA_HAS_LSX" ++ "@ ++ vor.v\t%w0,%w1,%w2 ++ vbitseti.%v0\t%w0,%w1,%V2 ++ vori.b\t%w0,%w1,%B2" ++ (set_attr "type" "simd_logic,simd_bit,simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "and<mode>3" ++ (set (match_operand:LSX 0 "register_operand" "=f,f,f") ++ (and:LSX ++ (match_operand:LSX 1 "register_operand" "f,f,f") ++ (match_operand:LSX 2 "reg_or_vector_same_val_operand" "f,YZ,Urv8"))) ++ "ISA_HAS_LSX" ++{ ++ switch (which_alternative) ++ { ++ case 0: ++ return "vand.v\t%w0,%w1,%w2"; ++ case 1: ++ { ++ rtx elt0 = CONST_VECTOR_ELT (operands2, 0); ++ unsigned HOST_WIDE_INT val = ~UINTVAL (elt0); ++ operands2 = loongarch_gen_const_int_vector (<MODE>mode, val & (-val)); ++ return "vbitclri.%v0\t%w0,%w1,%V2"; ++ } ++ case 2: ++ return "vandi.b\t%w0,%w1,%B2"; ++ default: ++ gcc_unreachable (); ++ } ++} ++ (set_attr "type" "simd_logic,simd_bit,simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "one_cmpl<mode>2" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (not:ILSX (match_operand:ILSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vnor.v\t%w0,%w1,%w1" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "TI")) ++ ++(define_insn "vlshr<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (lshiftrt:ILSX ++ (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_uimm6_operand" "f,Uuv6"))) ++ "ISA_HAS_LSX" ++ "@ ++ vsrl.<lsxfmt>\t%w0,%w1,%w2 ++ vsrli.<lsxfmt>\t%w0,%w1,%E2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "vashr<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (ashiftrt:ILSX ++ (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_uimm6_operand" "f,Uuv6"))) ++ "ISA_HAS_LSX" ++ "@ ++ vsra.<lsxfmt>\t%w0,%w1,%w2 ++ vsrai.<lsxfmt>\t%w0,%w1,%E2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "vashl<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (ashift:ILSX ++ (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_uimm6_operand" "f,Uuv6"))) ++ "ISA_HAS_LSX" ++ "@ ++ vsll.<lsxfmt>\t%w0,%w1,%w2 ++ vslli.<lsxfmt>\t%w0,%w1,%E2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++;; Floating-point operations ++(define_insn "add<mode>3" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (plus:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfadd.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "sub<mode>3" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (minus:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfsub.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "mul<mode>3" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (mult:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfmul.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fmul") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "div<mode>3" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (div:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfdiv.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fma<mode>4" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (fma:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ (match_operand:FLSX 3 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfmadd.<flsxfmt>\t%w0,%w1,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fnma<mode>4" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (fma:FLSX (neg:FLSX (match_operand:FLSX 1 "register_operand" "f")) ++ (match_operand:FLSX 2 "register_operand" "f") ++ (match_operand:FLSX 3 "register_operand" "0"))) ++ "ISA_HAS_LSX" ++ "vfnmsub.<flsxfmt>\t%w0,%w1,%w2,%w0" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "sqrt<mode>2" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (sqrt:FLSX (match_operand:FLSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfsqrt.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++;; Built-in functions ++(define_insn "lsx_vadda_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (plus:ILSX (abs:ILSX (match_operand:ILSX 1 "register_operand" "f")) ++ (abs:ILSX (match_operand:ILSX 2 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vadda.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "ssadd<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (ss_plus:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vsadd.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "usadd<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (us_plus:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vsadd.<lsxfmt_u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vabsd_s_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_ABSD_S)) ++ "ISA_HAS_LSX" ++ "vabsd.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vabsd_u_<lsxfmt_u>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VABSD_U)) ++ "ISA_HAS_LSX" ++ "vabsd.<lsxfmt_u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vavg_s_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VAVG_S)) ++ "ISA_HAS_LSX" ++ "vavg.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vavg_u_<lsxfmt_u>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VAVG_U)) ++ "ISA_HAS_LSX" ++ "vavg.<lsxfmt_u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vavgr_s_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VAVGR_S)) ++ "ISA_HAS_LSX" ++ "vavgr.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vavgr_u_<lsxfmt_u>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VAVGR_U)) ++ "ISA_HAS_LSX" ++ "vavgr.<lsxfmt_u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbitclr_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VBITCLR)) ++ "ISA_HAS_LSX" ++ "vbitclr.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbitclri_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VBITCLRI)) ++ "ISA_HAS_LSX" ++ "vbitclri.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbitrev_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VBITREV)) ++ "ISA_HAS_LSX" ++ "vbitrev.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbitrevi_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_lsx_branch_operand" "") ++ UNSPEC_LSX_VBITREVI)) ++ "ISA_HAS_LSX" ++ "vbitrevi.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbitsel_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (ior:ILSX (and:ILSX (not:ILSX ++ (match_operand:ILSX 3 "register_operand" "f")) ++ (match_operand:ILSX 1 "register_operand" "f")) ++ (and:ILSX (match_dup 3) ++ (match_operand:ILSX 2 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vbitsel.v\t%w0,%w1,%w2,%w3" ++ (set_attr "type" "simd_bitmov") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbitseli_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (ior:V16QI (and:V16QI (not:V16QI ++ (match_operand:V16QI 1 "register_operand" "0")) ++ (match_operand:V16QI 2 "register_operand" "f")) ++ (and:V16QI (match_dup 1) ++ (match_operand:V16QI 3 "const_vector_same_val_operand" "Urv8")))) ++ "ISA_HAS_LSX" ++ "vbitseli.b\t%w0,%w2,%B3" ++ (set_attr "type" "simd_bitmov") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vbitset_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VBITSET)) ++ "ISA_HAS_LSX" ++ "vbitset.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbitseti_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VBITSETI)) ++ "ISA_HAS_LSX" ++ "vbitseti.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_code_iterator ICC eq le leu lt ltu) ++ ++(define_code_attr icc ++ (eq "eq") ++ (le "le") ++ (leu "le") ++ (lt "lt") ++ (ltu "lt")) ++ ++(define_code_attr icci ++ (eq "eqi") ++ (le "lei") ++ (leu "lei") ++ (lt "lti") ++ (ltu "lti")) ++ ++(define_code_attr cmpi ++ (eq "s") ++ (le "s") ++ (leu "u") ++ (lt "s") ++ (ltu "u")) ++ ++(define_code_attr cmpi_1 ++ (eq "") ++ (le "") ++ (leu "u") ++ (lt "") ++ (ltu "u")) ++ ++(define_insn "lsx_vs<ICC:icc>_<ILSX:lsxfmt><ICC:cmpi_1>" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (ICC:ILSX ++ (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_<ICC:cmpi>imm5_operand" "f,U<ICC:cmpi>v5"))) ++ "ISA_HAS_LSX" ++ "@ ++ vs<ICC:icc>.<ILSX:lsxfmt><ICC:cmpi_1>\t%w0,%w1,%w2 ++ vs<ICC:icci>.<ILSX:lsxfmt><ICC:cmpi_1>\t%w0,%w1,%E2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfclass_<flsxfmt>" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (unspec:<VIMODE> (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFCLASS)) ++ "ISA_HAS_LSX" ++ "vfclass.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fclass") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfcmp_caf_<flsxfmt>" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (unspec:<VIMODE> (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ UNSPEC_LSX_VFCMP_CAF)) ++ "ISA_HAS_LSX" ++ "vfcmp.caf.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfcmp_cune_<FLSX:flsxfmt>" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (unspec:<VIMODE> (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ UNSPEC_LSX_VFCMP_CUNE)) ++ "ISA_HAS_LSX" ++ "vfcmp.cune.<FLSX:flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++(define_code_iterator vfcond unordered ordered eq ne le lt uneq unle unlt) ++ ++(define_code_attr fcc ++ (unordered "cun") ++ (ordered "cor") ++ (eq "ceq") ++ (ne "cne") ++ (uneq "cueq") ++ (unle "cule") ++ (unlt "cult") ++ (le "cle") ++ (lt "clt")) ++ ++(define_int_iterator FSC_UNS UNSPEC_LSX_VFCMP_SAF UNSPEC_LSX_VFCMP_SUN UNSPEC_LSX_VFCMP_SOR ++ UNSPEC_LSX_VFCMP_SEQ UNSPEC_LSX_VFCMP_SNE UNSPEC_LSX_VFCMP_SUEQ ++ UNSPEC_LSX_VFCMP_SUNE UNSPEC_LSX_VFCMP_SULE UNSPEC_LSX_VFCMP_SULT ++ UNSPEC_LSX_VFCMP_SLE UNSPEC_LSX_VFCMP_SLT) ++ ++(define_int_attr fsc ++ (UNSPEC_LSX_VFCMP_SAF "saf") ++ (UNSPEC_LSX_VFCMP_SUN "sun") ++ (UNSPEC_LSX_VFCMP_SOR "sor") ++ (UNSPEC_LSX_VFCMP_SEQ "seq") ++ (UNSPEC_LSX_VFCMP_SNE "sne") ++ (UNSPEC_LSX_VFCMP_SUEQ "sueq") ++ (UNSPEC_LSX_VFCMP_SUNE "sune") ++ (UNSPEC_LSX_VFCMP_SULE "sule") ++ (UNSPEC_LSX_VFCMP_SULT "sult") ++ (UNSPEC_LSX_VFCMP_SLE "sle") ++ (UNSPEC_LSX_VFCMP_SLT "slt")) ++ ++(define_insn "lsx_vfcmp_<vfcond:fcc>_<FLSX:flsxfmt>" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (vfcond:<VIMODE> (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfcmp.<vfcond:fcc>.<FLSX:flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfcmp_<fsc>_<FLSX:flsxfmt>" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (unspec:<VIMODE> (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ FSC_UNS)) ++ "ISA_HAS_LSX" ++ "vfcmp.<fsc>.<FLSX:flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "<MODE>")) ++ ++(define_mode_attr fint ++ (V4SF "v4si") ++ (V2DF "v2di")) ++ ++(define_mode_attr FINTCNV ++ (V4SF "I2S") ++ (V2DF "I2D")) ++ ++(define_mode_attr FINTCNV_2 ++ (V4SF "S2I") ++ (V2DF "D2I")) ++ ++(define_insn "float<fint><FLSX:mode>2" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (float:FLSX (match_operand:<VIMODE> 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vffint.<flsxfmt>.<ilsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "floatuns<fint><FLSX:mode>2" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (unsigned_float:FLSX ++ (match_operand:<VIMODE> 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vffint.<flsxfmt>.<ilsxfmt_u>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_mode_attr FFQ ++ (V4SF "V8HI") ++ (V2DF "V4SI")) ++ ++(define_insn "lsx_vreplgr2vr_<lsxfmt_f>" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (vec_duplicate:ILSX ++ (match_operand:<UNITMODE> 1 "reg_or_0_operand" "r,J"))) ++ "ISA_HAS_LSX" ++{ ++ if (which_alternative == 1) ++ return "ldi.<lsxfmt>\t%w0,0"; ++ ++ if (!TARGET_64BIT && (<MODE>mode == V2DImode || <MODE>mode == V2DFmode)) ++ return "#"; ++ else ++ return "vreplgr2vr.<lsxfmt>\t%w0,%z1"; ++} ++ (set_attr "type" "simd_fill") ++ (set_attr "mode" "<MODE>")) ++ ++(define_split ++ (set (match_operand:LSX_D 0 "register_operand") ++ (vec_duplicate:LSX_D ++ (match_operand:<UNITMODE> 1 "register_operand"))) ++ "reload_completed && ISA_HAS_LSX && !TARGET_64BIT" ++ (const_int 0) ++{ ++ loongarch_split_lsx_fill_d (operands0, operands1); ++ DONE; ++}) ++ ++(define_insn "logb<mode>2" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (unspec:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFLOGB)) ++ "ISA_HAS_LSX" ++ "vflogb.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_flog2") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "smax<mode>3" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (smax:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfmax.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfmaxa_<flsxfmt>" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (if_then_else:FLSX ++ (gt (abs:FLSX (match_operand:FLSX 1 "register_operand" "f")) ++ (abs:FLSX (match_operand:FLSX 2 "register_operand" "f"))) ++ (match_dup 1) ++ (match_dup 2))) ++ "ISA_HAS_LSX" ++ "vfmaxa.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "smin<mode>3" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (smin:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfmin.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfmina_<flsxfmt>" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (if_then_else:FLSX ++ (lt (abs:FLSX (match_operand:FLSX 1 "register_operand" "f")) ++ (abs:FLSX (match_operand:FLSX 2 "register_operand" "f"))) ++ (match_dup 1) ++ (match_dup 2))) ++ "ISA_HAS_LSX" ++ "vfmina.<flsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fminmax") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfrecip_<flsxfmt>" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (unspec:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFRECIP)) ++ "ISA_HAS_LSX" ++ "vfrecip.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfrint_<flsxfmt>" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (unspec:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINT)) ++ "ISA_HAS_LSX" ++ "vfrint.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfrsqrt_<flsxfmt>" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (unspec:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFRSQRT)) ++ "ISA_HAS_LSX" ++ "vfrsqrt.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fdiv") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vftint_s_<ilsxfmt>_<flsxfmt>" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (unspec:<VIMODE> (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINT_S)) ++ "ISA_HAS_LSX" ++ "vftint.<ilsxfmt>.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV_2>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vftint_u_<ilsxfmt_u>_<flsxfmt>" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (unspec:<VIMODE> (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINT_U)) ++ "ISA_HAS_LSX" ++ "vftint.<ilsxfmt_u>.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV_2>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fix_trunc<FLSX:mode><mode_i>2" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (fix:<VIMODE> (match_operand:FLSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vftintrz.<ilsxfmt>.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV_2>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fixuns_trunc<FLSX:mode><mode_i>2" ++ (set (match_operand:<VIMODE> 0 "register_operand" "=f") ++ (unsigned_fix:<VIMODE> (match_operand:FLSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vftintrz.<ilsxfmt_u>.<flsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "cnv_mode" "<FINTCNV_2>") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vh<optab>w_h<u>_b<u>" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (addsub:V8HI ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))))) ++ "ISA_HAS_LSX" ++ "vh<optab>w.h<u>.b<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vh<optab>w_w<u>_h<u>" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (addsub:V4SI ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))))) ++ "ISA_HAS_LSX" ++ "vh<optab>w.w<u>.h<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vh<optab>w_d<u>_w<u>" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (addsub:V2DI ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 1 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3)))) ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2)))))) ++ "ISA_HAS_LSX" ++ "vh<optab>w.d<u>.w<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vpackev_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (vec_select:V16QI ++ (vec_concat:V32QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (match_operand:V16QI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 16) ++ (const_int 2) (const_int 18) ++ (const_int 4) (const_int 20) ++ (const_int 6) (const_int 22) ++ (const_int 8) (const_int 24) ++ (const_int 10) (const_int 26) ++ (const_int 12) (const_int 28) ++ (const_int 14) (const_int 30)))) ++ "ISA_HAS_LSX" ++ "vpackev.b\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vpackev_h" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (vec_select:V8HI ++ (vec_concat:V16HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (match_operand:V8HI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 8) ++ (const_int 2) (const_int 10) ++ (const_int 4) (const_int 12) ++ (const_int 6) (const_int 14)))) ++ "ISA_HAS_LSX" ++ "vpackev.h\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vpackev_w" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (vec_select:V4SI ++ (vec_concat:V8SI ++ (match_operand:V4SI 1 "register_operand" "f") ++ (match_operand:V4SI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 4) ++ (const_int 2) (const_int 6)))) ++ "ISA_HAS_LSX" ++ "vpackev.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vpackev_w_f" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (vec_select:V4SF ++ (vec_concat:V8SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (match_operand:V4SF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 4) ++ (const_int 2) (const_int 6)))) ++ "ISA_HAS_LSX" ++ "vpackev.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vilvh_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (vec_select:V16QI ++ (vec_concat:V32QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (match_operand:V16QI 2 "register_operand" "f")) ++ (parallel (const_int 8) (const_int 24) ++ (const_int 9) (const_int 25) ++ (const_int 10) (const_int 26) ++ (const_int 11) (const_int 27) ++ (const_int 12) (const_int 28) ++ (const_int 13) (const_int 29) ++ (const_int 14) (const_int 30) ++ (const_int 15) (const_int 31)))) ++ "ISA_HAS_LSX" ++ "vilvh.b\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vilvh_h" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (vec_select:V8HI ++ (vec_concat:V16HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (match_operand:V8HI 2 "register_operand" "f")) ++ (parallel (const_int 4) (const_int 12) ++ (const_int 5) (const_int 13) ++ (const_int 6) (const_int 14) ++ (const_int 7) (const_int 15)))) ++ "ISA_HAS_LSX" ++ "vilvh.h\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8HI")) ++ ++(define_mode_attr vilvh_suffix ++ (V4SI "") (V4SF "_f") ++ (V2DI "") (V2DF "_f")) ++ ++(define_insn "lsx_vilvh_w<vilvh_suffix>" ++ (set (match_operand:LSX_W 0 "register_operand" "=f") ++ (vec_select:LSX_W ++ (vec_concat:<VEMODE> ++ (match_operand:LSX_W 1 "register_operand" "f") ++ (match_operand:LSX_W 2 "register_operand" "f")) ++ (parallel (const_int 2) (const_int 6) ++ (const_int 3) (const_int 7)))) ++ "ISA_HAS_LSX" ++ "vilvh.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vilvh_d<vilvh_suffix>" ++ (set (match_operand:LSX_D 0 "register_operand" "=f") ++ (vec_select:LSX_D ++ (vec_concat:<VEMODE> ++ (match_operand:LSX_D 1 "register_operand" "f") ++ (match_operand:LSX_D 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3)))) ++ "ISA_HAS_LSX" ++ "vilvh.d\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vpackod_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (vec_select:V16QI ++ (vec_concat:V32QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (match_operand:V16QI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 17) ++ (const_int 3) (const_int 19) ++ (const_int 5) (const_int 21) ++ (const_int 7) (const_int 23) ++ (const_int 9) (const_int 25) ++ (const_int 11) (const_int 27) ++ (const_int 13) (const_int 29) ++ (const_int 15) (const_int 31)))) ++ "ISA_HAS_LSX" ++ "vpackod.b\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vpackod_h" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (vec_select:V8HI ++ (vec_concat:V16HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (match_operand:V8HI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 9) ++ (const_int 3) (const_int 11) ++ (const_int 5) (const_int 13) ++ (const_int 7) (const_int 15)))) ++ "ISA_HAS_LSX" ++ "vpackod.h\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vpackod_w" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (vec_select:V4SI ++ (vec_concat:V8SI ++ (match_operand:V4SI 1 "register_operand" "f") ++ (match_operand:V4SI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 5) ++ (const_int 3) (const_int 7)))) ++ "ISA_HAS_LSX" ++ "vpackod.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vpackod_w_f" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (vec_select:V4SF ++ (vec_concat:V8SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (match_operand:V4SF 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 5) ++ (const_int 3) (const_int 7)))) ++ "ISA_HAS_LSX" ++ "vpackod.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vilvl_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (vec_select:V16QI ++ (vec_concat:V32QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (match_operand:V16QI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 16) ++ (const_int 1) (const_int 17) ++ (const_int 2) (const_int 18) ++ (const_int 3) (const_int 19) ++ (const_int 4) (const_int 20) ++ (const_int 5) (const_int 21) ++ (const_int 6) (const_int 22) ++ (const_int 7) (const_int 23)))) ++ "ISA_HAS_LSX" ++ "vilvl.b\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vilvl_h" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (vec_select:V8HI ++ (vec_concat:V16HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (match_operand:V8HI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 8) ++ (const_int 1) (const_int 9) ++ (const_int 2) (const_int 10) ++ (const_int 3) (const_int 11)))) ++ "ISA_HAS_LSX" ++ "vilvl.h\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vilvl_w" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (vec_select:V4SI ++ (vec_concat:V8SI ++ (match_operand:V4SI 1 "register_operand" "f") ++ (match_operand:V4SI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 4) ++ (const_int 1) (const_int 5)))) ++ "ISA_HAS_LSX" ++ "vilvl.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vilvl_w_f" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (vec_select:V4SF ++ (vec_concat:V8SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (match_operand:V4SF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 4) ++ (const_int 1) (const_int 5)))) ++ "ISA_HAS_LSX" ++ "vilvl.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vilvl_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (vec_select:V2DI ++ (vec_concat:V4DI ++ (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2)))) ++ "ISA_HAS_LSX" ++ "vilvl.d\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vilvl_d_f" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (vec_select:V2DF ++ (vec_concat:V4DF ++ (match_operand:V2DF 1 "register_operand" "f") ++ (match_operand:V2DF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2)))) ++ "ISA_HAS_LSX" ++ "vilvl.d\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "smax<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (smax:ILSX (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_simm5_operand" "f,Usv5"))) ++ "ISA_HAS_LSX" ++ "@ ++ vmax.<lsxfmt>\t%w0,%w1,%w2 ++ vmaxi.<lsxfmt>\t%w0,%w1,%E2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "umax<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (umax:ILSX (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_uimm5_operand" "f,Uuv5"))) ++ "ISA_HAS_LSX" ++ "@ ++ vmax.<lsxfmt_u>\t%w0,%w1,%w2 ++ vmaxi.<lsxfmt_u>\t%w0,%w1,%B2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "smin<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (smin:ILSX (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_simm5_operand" "f,Usv5"))) ++ "ISA_HAS_LSX" ++ "@ ++ vmin.<lsxfmt>\t%w0,%w1,%w2 ++ vmini.<lsxfmt>\t%w0,%w1,%E2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "umin<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (umin:ILSX (match_operand:ILSX 1 "register_operand" "f,f") ++ (match_operand:ILSX 2 "reg_or_vector_same_uimm5_operand" "f,Uuv5"))) ++ "ISA_HAS_LSX" ++ "@ ++ vmin.<lsxfmt_u>\t%w0,%w1,%w2 ++ vmini.<lsxfmt_u>\t%w0,%w1,%B2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vclo_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (clz:ILSX (not:ILSX (match_operand:ILSX 1 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vclo.<lsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "clz<mode>2" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (clz:ILSX (match_operand:ILSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vclz.<lsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_nor_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f,f") ++ (and:ILSX (not:ILSX (match_operand:ILSX 1 "register_operand" "f,f")) ++ (not:ILSX (match_operand:ILSX 2 "reg_or_vector_same_val_operand" "f,Urv8")))) ++ "ISA_HAS_LSX" ++ "@ ++ vnor.v\t%w0,%w1,%w2 ++ vnori.b\t%w0,%w1,%B2" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vpickev_b" ++(set (match_operand:V16QI 0 "register_operand" "=f") ++ (vec_select:V16QI ++ (vec_concat:V32QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (match_operand:V16QI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14) ++ (const_int 16) (const_int 18) ++ (const_int 20) (const_int 22) ++ (const_int 24) (const_int 26) ++ (const_int 28) (const_int 30)))) ++ "ISA_HAS_LSX" ++ "vpickev.b\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vpickev_h" ++(set (match_operand:V8HI 0 "register_operand" "=f") ++ (vec_select:V8HI ++ (vec_concat:V16HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (match_operand:V8HI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ "ISA_HAS_LSX" ++ "vpickev.h\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vpickev_w" ++(set (match_operand:V4SI 0 "register_operand" "=f") ++ (vec_select:V4SI ++ (vec_concat:V8SI ++ (match_operand:V4SI 1 "register_operand" "f") ++ (match_operand:V4SI 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ "ISA_HAS_LSX" ++ "vpickev.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vpickev_w_f" ++(set (match_operand:V4SF 0 "register_operand" "=f") ++ (vec_select:V4SF ++ (vec_concat:V8SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (match_operand:V4SF 2 "register_operand" "f")) ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ "ISA_HAS_LSX" ++ "vpickev.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vpickod_b" ++(set (match_operand:V16QI 0 "register_operand" "=f") ++ (vec_select:V16QI ++ (vec_concat:V32QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (match_operand:V16QI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15) ++ (const_int 17) (const_int 19) ++ (const_int 21) (const_int 23) ++ (const_int 25) (const_int 27) ++ (const_int 29) (const_int 31)))) ++ "ISA_HAS_LSX" ++ "vpickod.b\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vpickod_h" ++(set (match_operand:V8HI 0 "register_operand" "=f") ++ (vec_select:V8HI ++ (vec_concat:V16HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (match_operand:V8HI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ "ISA_HAS_LSX" ++ "vpickod.h\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vpickod_w" ++(set (match_operand:V4SI 0 "register_operand" "=f") ++ (vec_select:V4SI ++ (vec_concat:V8SI ++ (match_operand:V4SI 1 "register_operand" "f") ++ (match_operand:V4SI 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ "ISA_HAS_LSX" ++ "vpickod.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vpickod_w_f" ++(set (match_operand:V4SF 0 "register_operand" "=f") ++ (vec_select:V4SF ++ (vec_concat:V8SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (match_operand:V4SF 2 "register_operand" "f")) ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ "ISA_HAS_LSX" ++ "vpickod.w\t%w0,%w2,%w1" ++ (set_attr "type" "simd_permute") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "popcount<mode>2" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (popcount:ILSX (match_operand:ILSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vpcnt.<lsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_pcnt") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsat_s_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSAT_S)) ++ "ISA_HAS_LSX" ++ "vsat.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_sat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsat_u_<lsxfmt_u>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSAT_U)) ++ "ISA_HAS_LSX" ++ "vsat.<lsxfmt_u>\t%w0,%w1,%2" ++ (set_attr "type" "simd_sat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vshuf4i_<lsxfmt_f>" ++ (set (match_operand:LSX_WHB_W 0 "register_operand" "=f") ++ (vec_select:LSX_WHB_W ++ (match_operand:LSX_WHB_W 1 "register_operand" "f") ++ (match_operand 2 "par_const_vector_shf_set_operand" ""))) ++ "ISA_HAS_LSX" ++{ ++ HOST_WIDE_INT val = 0; ++ unsigned int i; ++ ++ /* We convert the selection to an immediate. */ ++ for (i = 0; i < 4; i++) ++ val |= INTVAL (XVECEXP (operands2, 0, i)) << (2 * i); ++ ++ operands2 = GEN_INT (val); ++ return "vshuf4i.<lsxfmt>\t%w0,%w1,%X2"; ++} ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrar_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VSRAR)) ++ "ISA_HAS_LSX" ++ "vsrar.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrari_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSRARI)) ++ "ISA_HAS_LSX" ++ "vsrari.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrlr_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VSRLR)) ++ "ISA_HAS_LSX" ++ "vsrlr.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrlri_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSRLRI)) ++ "ISA_HAS_LSX" ++ "vsrlri.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssub_s_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (ss_minus:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vssub.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssub_u_<lsxfmt_u>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (us_minus:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vssub.<lsxfmt_u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vreplve_<lsxfmt_f>" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (vec_duplicate:LSX ++ (vec_select:<UNITMODE> ++ (match_operand:LSX 1 "register_operand" "f") ++ (parallel (match_operand:SI 2 "register_operand" "r"))))) ++ "ISA_HAS_LSX" ++ "vreplve.<lsxfmt>\t%w0,%w1,%z2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vreplvei_<lsxfmt_f>" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (vec_duplicate:LSX ++ (vec_select:<UNITMODE> ++ (match_operand:LSX 1 "register_operand" "f") ++ (parallel (match_operand 2 "const_<indeximm>_operand" ""))))) ++ "ISA_HAS_LSX" ++ "vreplvei.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vreplvei_<lsxfmt_f>_scalar" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (vec_duplicate:LSX ++ (match_operand:<UNITMODE> 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vreplvei.<lsxfmt>\t%w0,%w1,0" ++ (set_attr "type" "simd_splat") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfcvt_h_s" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (unspec:V8HI (match_operand:V4SF 1 "register_operand" "f") ++ (match_operand:V4SF 2 "register_operand" "f") ++ UNSPEC_LSX_VFCVT)) ++ "ISA_HAS_LSX" ++ "vfcvt.h.s\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vfcvt_s_d" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V2DF 1 "register_operand" "f") ++ (match_operand:V2DF 2 "register_operand" "f") ++ UNSPEC_LSX_VFCVT)) ++ "ISA_HAS_LSX" ++ "vfcvt.s.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "vec_pack_trunc_v2df" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (vec_concat:V4SF ++ (float_truncate:V2SF (match_operand:V2DF 1 "register_operand" "f")) ++ (float_truncate:V2SF (match_operand:V2DF 2 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vfcvt.s.d\t%w0,%w2,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfcvth_s_h" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V8HI 1 "register_operand" "f") ++ UNSPEC_LSX_VFCVTH)) ++ "ISA_HAS_LSX" ++ "vfcvth.s.h\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfcvth_d_s" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (float_extend:V2DF ++ (vec_select:V2SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (parallel (const_int 2) (const_int 3))))) ++ "ISA_HAS_LSX" ++ "vfcvth.d.s\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vfcvtl_s_h" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V8HI 1 "register_operand" "f") ++ UNSPEC_LSX_VFCVTL)) ++ "ISA_HAS_LSX" ++ "vfcvtl.s.h\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfcvtl_d_s" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (float_extend:V2DF ++ (vec_select:V2SF ++ (match_operand:V4SF 1 "register_operand" "f") ++ (parallel (const_int 0) (const_int 1))))) ++ "ISA_HAS_LSX" ++ "vfcvtl.d.s\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V2DF")) ++ ++(define_code_attr lsxbr ++ (eq "bz") ++ (ne "bnz")) ++ ++(define_code_attr lsxeq_v ++ (eq "eqz") ++ (ne "nez")) ++ ++(define_code_attr lsxne_v ++ (eq "nez") ++ (ne "eqz")) ++ ++(define_code_attr lsxeq ++ (eq "anyeqz") ++ (ne "allnez")) ++ ++(define_code_attr lsxne ++ (eq "allnez") ++ (ne "anyeqz")) ++ ++(define_insn "lsx_<lsxbr>_<lsxfmt_f>" ++ (set (pc) (if_then_else ++ (equality_op ++ (unspec:SI (match_operand:LSX 1 "register_operand" "f") ++ UNSPEC_LSX_BRANCH) ++ (match_operand:SI 2 "const_0_operand")) ++ (label_ref (match_operand 0)) ++ (pc))) ++ (clobber (match_scratch:FCC 3 "=z")) ++ "ISA_HAS_LSX" ++{ ++ return loongarch_output_conditional_branch (insn, operands, ++ "vset<lsxeq>.<lsxfmt>\t%Z3%w1\n\tbcnez\t%Z3%0", ++ "vset<lsxne>.<lsxfmt>\t%Z3%w1\n\tbcnez\t%Z3%0"); ++} ++ (set_attr "type" "simd_branch") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_<lsxbr>_v_<lsxfmt_f>" ++ (set (pc) (if_then_else ++ (equality_op ++ (unspec:SI (match_operand:LSX 1 "register_operand" "f") ++ UNSPEC_LSX_BRANCH_V) ++ (match_operand:SI 2 "const_0_operand")) ++ (label_ref (match_operand 0)) ++ (pc))) ++ (clobber (match_scratch:FCC 3 "=z")) ++ "ISA_HAS_LSX" ++{ ++ return loongarch_output_conditional_branch (insn, operands, ++ "vset<lsxeq_v>.v\t%Z3%w1\n\tbcnez\t%Z3%0", ++ "vset<lsxne_v>.v\t%Z3%w1\n\tbcnez\t%Z3%0"); ++} ++ (set_attr "type" "simd_branch") ++ (set_attr "mode" "TI")) ++ ++;; vec_concate ++(define_expand "vec_concatv2di" ++ (set (match_operand:V2DI 0 "register_operand") ++ (vec_concat:V2DI ++ (match_operand:DI 1 "register_operand") ++ (match_operand:DI 2 "register_operand"))) ++ "ISA_HAS_LSX" ++{ ++ emit_insn (gen_lsx_vinsgr2vr_d (operands0, operands1, ++ operands0, GEN_INT (0))); ++ emit_insn (gen_lsx_vinsgr2vr_d (operands0, operands2, ++ operands0, GEN_INT (1))); ++ DONE; ++}) ++ ++ ++(define_insn "vandn<mode>3" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (and:LSX (not:LSX (match_operand:LSX 1 "register_operand" "f")) ++ (match_operand:LSX 2 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vandn.v\t%w0,%w1,%w2" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "vabs<mode>2" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (abs:ILSX (match_operand:ILSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vsigncov.<lsxfmt>\t%w0,%w1,%w1" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "vneg<mode>2" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (neg:ILSX (match_operand:ILSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vneg.<lsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vmuh_s_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VMUH_S)) ++ "ISA_HAS_LSX" ++ "vmuh.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vmuh_u_<lsxfmt_u>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VMUH_U)) ++ "ISA_HAS_LSX" ++ "vmuh.<lsxfmt_u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vextw_s_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SI 1 "register_operand" "f") ++ UNSPEC_LSX_VEXTW_S)) ++ "ISA_HAS_LSX" ++ "vextw_s.d\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vextw_u_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SI 1 "register_operand" "f") ++ UNSPEC_LSX_VEXTW_U)) ++ "ISA_HAS_LSX" ++ "vextw_u.d\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vsllwil_s_<dlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VDMODE> 0 "register_operand" "=f") ++ (unspec:<VDMODE> (match_operand:ILSX_WHB 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSLLWIL_S)) ++ "ISA_HAS_LSX" ++ "vsllwil.<dlsxfmt>.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsllwil_u_<dlsxfmt_u>_<lsxfmt_u>" ++ (set (match_operand:<VDMODE> 0 "register_operand" "=f") ++ (unspec:<VDMODE> (match_operand:ILSX_WHB 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSLLWIL_U)) ++ "ISA_HAS_LSX" ++ "vsllwil.<dlsxfmt_u>.<lsxfmt_u>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsran_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSRAN)) ++ "ISA_HAS_LSX" ++ "vsran.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssran_s_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRAN_S)) ++ "ISA_HAS_LSX" ++ "vssran.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssran_u_<hlsxfmt_u>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRAN_U)) ++ "ISA_HAS_LSX" ++ "vssran.<hlsxfmt_u>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrain_<hlsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSRAIN)) ++ "ISA_HAS_LSX" ++ "vsrain.<hlsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++;; FIXME: bitimm ++(define_insn "lsx_vsrains_s_<hlsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSRAINS_S)) ++ "ISA_HAS_LSX" ++ "vsrains_s.<hlsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++;; FIXME: bitimm ++(define_insn "lsx_vsrains_u_<hlsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" "") ++ UNSPEC_LSX_VSRAINS_U)) ++ "ISA_HAS_LSX" ++ "vsrains_u.<hlsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrarn_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSRARN)) ++ "ISA_HAS_LSX" ++ "vsrarn.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrarn_s_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRARN_S)) ++ "ISA_HAS_LSX" ++ "vssrarn.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrarn_u_<hlsxfmt_u>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRARN_U)) ++ "ISA_HAS_LSX" ++ "vssrarn.<hlsxfmt_u>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrln_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSRLN)) ++ "ISA_HAS_LSX" ++ "vsrln.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrln_u_<hlsxfmt_u>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRLN_U)) ++ "ISA_HAS_LSX" ++ "vssrln.<hlsxfmt_u>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrlrn_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSRLRN)) ++ "ISA_HAS_LSX" ++ "vsrlrn.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrlrn_u_<hlsxfmt_u>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRLRN_U)) ++ "ISA_HAS_LSX" ++ "vssrlrn.<hlsxfmt_u>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfrstpi_<lsxfmt>" ++ (set (match_operand:ILSX_HB 0 "register_operand" "=f") ++ (unspec:ILSX_HB (match_operand:ILSX_HB 1 "register_operand" "0") ++ (match_operand:ILSX_HB 2 "register_operand" "f") ++ (match_operand 3 "const_uimm5_operand" "") ++ UNSPEC_LSX_VFRSTPI)) ++ "ISA_HAS_LSX" ++ "vfrstpi.<lsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vfrstp_<lsxfmt>" ++ (set (match_operand:ILSX_HB 0 "register_operand" "=f") ++ (unspec:ILSX_HB (match_operand:ILSX_HB 1 "register_operand" "0") ++ (match_operand:ILSX_HB 2 "register_operand" "f") ++ (match_operand:ILSX_HB 3 "register_operand" "f") ++ UNSPEC_LSX_VFRSTP)) ++ "ISA_HAS_LSX" ++ "vfrstp.<lsxfmt>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vshuf4i_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand") ++ UNSPEC_LSX_VSHUF4I)) ++ "ISA_HAS_LSX" ++ "vshuf4i.d\t%w0,%w2,%3" ++ (set_attr "type" "simd_sld") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vbsrl_<lsxfmt_f>" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (unspec:LSX (match_operand:LSX 1 "register_operand" "f") ++ (match_operand 2 "const_uimm5_operand" "") ++ UNSPEC_LSX_VBSRL_V)) ++ "ISA_HAS_LSX" ++ "vbsrl.v\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vbsll_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_uimm5_operand" "") ++ UNSPEC_LSX_VBSLL_V)) ++ "ISA_HAS_LSX" ++ "vbsll.v\t%w0,%w1,%2" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vextrins_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VEXTRINS)) ++ "ISA_HAS_LSX" ++ "vextrins.<lsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vmskltz_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ UNSPEC_LSX_VMSKLTZ)) ++ "ISA_HAS_LSX" ++ "vmskltz.<lsxfmt>\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsigncov_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VSIGNCOV)) ++ "ISA_HAS_LSX" ++ "vsigncov.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_expand "copysign<mode>3" ++ (set (match_dup 4) ++ (and:FLSX ++ (not:FLSX (match_dup 3)) ++ (match_operand:FLSX 1 "register_operand"))) ++ (set (match_dup 5) ++ (and:FLSX (match_dup 3) ++ (match_operand:FLSX 2 "register_operand"))) ++ (set (match_operand:FLSX 0 "register_operand") ++ (ior:FLSX (match_dup 4) (match_dup 5))) ++ "ISA_HAS_LSX" ++{ ++ operands3 = loongarch_build_signbit_mask (<MODE>mode, 1, 0); ++ ++ operands4 = gen_reg_rtx (<MODE>mode); ++ operands5 = gen_reg_rtx (<MODE>mode); ++}) ++ ++(define_insn "absv2df2" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (abs:V2DF (match_operand:V2DF 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vbitclri.d\t%w0,%w1,63" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "absv4sf2" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (abs:V4SF (match_operand:V4SF 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vbitclri.w\t%w0,%w1,31" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "vfmadd<mode>4" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (fma:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ (match_operand:FLSX 3 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vfmadd.<flsxfmt>\t%w0,%w1,$w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fms<mode>4" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (fma:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ (neg:FLSX (match_operand:FLSX 3 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vfmsub.<flsxfmt>\t%w0,%w1,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "vfnmsub<mode>4_nmsub4" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (neg:FLSX ++ (fma:FLSX ++ (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ (neg:FLSX (match_operand:FLSX 3 "register_operand" "f"))))) ++ "ISA_HAS_LSX" ++ "vfnmsub.<flsxfmt>\t%w0,%w1,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "vfnmadd<mode>4_nmadd4" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (neg:FLSX ++ (fma:FLSX ++ (match_operand:FLSX 1 "register_operand" "f") ++ (match_operand:FLSX 2 "register_operand" "f") ++ (match_operand:FLSX 3 "register_operand" "f")))) ++ "ISA_HAS_LSX" ++ "vfnmadd.<flsxfmt>\t%w0,%w1,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vftintrne_w_s" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRNE)) ++ "ISA_HAS_LSX" ++ "vftintrne.w.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrne_l_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRNE)) ++ "ISA_HAS_LSX" ++ "vftintrne.l.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vftintrp_w_s" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRP)) ++ "ISA_HAS_LSX" ++ "vftintrp.w.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrp_l_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRP)) ++ "ISA_HAS_LSX" ++ "vftintrp.l.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vftintrm_w_s" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRM)) ++ "ISA_HAS_LSX" ++ "vftintrm.w.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrm_l_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRM)) ++ "ISA_HAS_LSX" ++ "vftintrm.l.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vftint_w_d" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V2DF 1 "register_operand" "f") ++ (match_operand:V2DF 2 "register_operand" "f") ++ UNSPEC_LSX_VFTINT_W_D)) ++ "ISA_HAS_LSX" ++ "vftint.w.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vffint_s_l" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VFFINT_S_L)) ++ "ISA_HAS_LSX" ++ "vffint.s.l\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vftintrz_w_d" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V2DF 1 "register_operand" "f") ++ (match_operand:V2DF 2 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRZ_W_D)) ++ "ISA_HAS_LSX" ++ "vftintrz.w.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vftintrp_w_d" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V2DF 1 "register_operand" "f") ++ (match_operand:V2DF 2 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRP_W_D)) ++ "ISA_HAS_LSX" ++ "vftintrp.w.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vftintrm_w_d" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V2DF 1 "register_operand" "f") ++ (match_operand:V2DF 2 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRM_W_D)) ++ "ISA_HAS_LSX" ++ "vftintrm.w.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vftintrne_w_d" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V2DF 1 "register_operand" "f") ++ (match_operand:V2DF 2 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRNE_W_D)) ++ "ISA_HAS_LSX" ++ "vftintrne.w.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vftinth_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTH_L_H)) ++ "ISA_HAS_LSX" ++ "vftinth.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintl_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTL_L_S)) ++ "ISA_HAS_LSX" ++ "vftintl.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vffinth_d_w" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (unspec:V2DF (match_operand:V4SI 1 "register_operand" "f") ++ UNSPEC_LSX_VFFINTH_D_W)) ++ "ISA_HAS_LSX" ++ "vffinth.d.w\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vffintl_d_w" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (unspec:V2DF (match_operand:V4SI 1 "register_operand" "f") ++ UNSPEC_LSX_VFFINTL_D_W)) ++ "ISA_HAS_LSX" ++ "vffintl.d.w\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vftintrzh_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRZH_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrzh.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrzl_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRZL_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrzl.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrph_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRPH_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrph.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrpl_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRPL_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrpl.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrmh_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRMH_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrmh.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrml_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRML_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrml.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrneh_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRNEH_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrneh.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vftintrnel_l_s" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFTINTRNEL_L_S)) ++ "ISA_HAS_LSX" ++ "vftintrnel.l.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfrintrne_s" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRNE_S)) ++ "ISA_HAS_LSX" ++ "vfrintrne.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfrintrne_d" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (unspec:V2DF (match_operand:V2DF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRNE_D)) ++ "ISA_HAS_LSX" ++ "vfrintrne.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vfrintrz_s" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRZ_S)) ++ "ISA_HAS_LSX" ++ "vfrintrz.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfrintrz_d" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (unspec:V2DF (match_operand:V2DF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRZ_D)) ++ "ISA_HAS_LSX" ++ "vfrintrz.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vfrintrp_s" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRP_S)) ++ "ISA_HAS_LSX" ++ "vfrintrp.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfrintrp_d" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (unspec:V2DF (match_operand:V2DF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRP_D)) ++ "ISA_HAS_LSX" ++ "vfrintrp.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++(define_insn "lsx_vfrintrm_s" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V4SF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRM_S)) ++ "ISA_HAS_LSX" ++ "vfrintrm.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "lsx_vfrintrm_d" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (unspec:V2DF (match_operand:V2DF 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINTRM_D)) ++ "ISA_HAS_LSX" ++ "vfrintrm.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++;; Vector versions of the floating-point frint patterns. ++;; Expands to btrunc, ceil, floor, rint. ++(define_insn "<FRINT_S:frint_pattern_s>v4sf2" ++ (set (match_operand:V4SF 0 "register_operand" "=f") ++ (unspec:V4SF (match_operand:V4SF 1 "register_operand" "f") ++ FRINT_S)) ++ "ISA_HAS_LSX" ++ "vfrint<FRINT_S:frint_suffix>.s\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V4SF")) ++ ++(define_insn "<FRINT_D:frint_pattern_d>v2df2" ++ (set (match_operand:V2DF 0 "register_operand" "=f") ++ (unspec:V2DF (match_operand:V2DF 1 "register_operand" "f") ++ FRINT_D)) ++ "ISA_HAS_LSX" ++ "vfrint<FRINT_D:frint_suffix>.d\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "V2DF")) ++ ++;; Expands to round. ++(define_insn "round<mode>2" ++ (set (match_operand:FLSX 0 "register_operand" "=f") ++ (unspec:FLSX (match_operand:FLSX 1 "register_operand" "f") ++ UNSPEC_LSX_VFRINT)) ++ "ISA_HAS_LSX" ++ "vfrint.<flsxfrint>\t%w0,%w1" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++;; Offset load and broadcast ++(define_expand "lsx_vldrepl_<lsxfmt_f>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq12<lsxfmt>_operand") ++ "ISA_HAS_LSX" ++{ ++ emit_insn (gen_lsx_vldrepl_<lsxfmt_f>_insn ++ (operands0, operands1, operands2)); ++ DONE; ++}) ++ ++(define_insn "lsx_vldrepl_<lsxfmt_f>_insn" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (vec_duplicate:LSX ++ (mem:<UNITMODE> (plus:DI (match_operand:DI 1 "register_operand" "r") ++ (match_operand 2 "aq12<lsxfmt>_operand"))))) ++ "ISA_HAS_LSX" ++{ ++ return "vldrepl.<lsxfmt>\t%w0,%1,%2"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++(define_insn "lsx_vldrepl_<lsxfmt_f>_insn_0" ++ (set (match_operand:LSX 0 "register_operand" "=f") ++ (vec_duplicate:LSX ++ (mem:<UNITMODE> (match_operand:DI 1 "register_operand" "r")))) ++ "ISA_HAS_LSX" ++{ ++ return "vldrepl.<lsxfmt>\t%w0,%1,0"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++;; Offset store by sel ++(define_expand "lsx_vstelm_<lsxfmt_f>" ++ (match_operand:LSX 0 "register_operand") ++ (match_operand 3 "const_<indeximm>_operand") ++ (match_operand 2 "aq8<lsxfmt>_operand") ++ (match_operand 1 "pmode_register_operand") ++ "ISA_HAS_LSX" ++{ ++ emit_insn (gen_lsx_vstelm_<lsxfmt_f>_insn ++ (operands1, operands2, operands0, operands3)); ++ DONE; ++}) ++ ++(define_insn "lsx_vstelm_<lsxfmt_f>_insn" ++ (set (mem:<UNITMODE> (plus:DI (match_operand:DI 0 "register_operand" "r") ++ (match_operand 1 "aq8<lsxfmt>_operand"))) ++ (vec_select:<UNITMODE> ++ (match_operand:LSX 2 "register_operand" "f") ++ (parallel (match_operand 3 "const_<indeximm>_operand" "")))) ++ ++ "ISA_HAS_LSX" ++{ ++ return "vstelm.<lsxfmt>\t%w2,%0,%1,%3"; ++} ++ (set_attr "type" "simd_store") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++;; Offset is "0" ++(define_insn "lsx_vstelm_<lsxfmt_f>_insn_0" ++ (set (mem:<UNITMODE> (match_operand:DI 0 "register_operand" "r")) ++ (vec_select:<UNITMODE> ++ (match_operand:LSX 1 "register_operand" "f") ++ (parallel (match_operand:SI 2 "const_<indeximm>_operand")))) ++ "ISA_HAS_LSX" ++{ ++ return "vstelm.<lsxfmt>\t%w1,%0,0,%2"; ++} ++ (set_attr "type" "simd_store") ++ (set_attr "mode" "<MODE>") ++ (set_attr "length" "4")) ++ ++(define_expand "lsx_vld" ++ (match_operand:V16QI 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq12b_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (operands0, gen_rtx_MEM (V16QImode, addr)); ++ DONE; ++}) ++ ++(define_expand "lsx_vst" ++ (match_operand:V16QI 0 "register_operand") ++ (match_operand 1 "pmode_register_operand") ++ (match_operand 2 "aq12b_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx addr = plus_constant (GET_MODE (operands1), operands1, ++ INTVAL (operands2)); ++ loongarch_emit_move (gen_rtx_MEM (V16QImode, addr), operands0); ++ DONE; ++}) ++ ++(define_insn "lsx_vssrln_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRLN)) ++ "ISA_HAS_LSX" ++ "vssrln.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++ ++(define_insn "lsx_vssrlrn_<hlsxfmt>_<lsxfmt>" ++ (set (match_operand:<VHMODE> 0 "register_operand" "=f") ++ (unspec:<VHMODE> (match_operand:ILSX_DWH 1 "register_operand" "f") ++ (match_operand:ILSX_DWH 2 "register_operand" "f") ++ UNSPEC_LSX_VSSRLRN)) ++ "ISA_HAS_LSX" ++ "vssrlrn.<hlsxfmt>.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "vorn<mode>3" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (ior:ILSX (not:ILSX (match_operand:ILSX 2 "register_operand" "f")) ++ (match_operand:ILSX 1 "register_operand" "f"))) ++ "ISA_HAS_LSX" ++ "vorn.v\t%w0,%w1,%w2" ++ (set_attr "type" "simd_logic") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vldi" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand 1 "const_imm13_operand") ++ UNSPEC_LSX_VLDI)) ++ "ISA_HAS_LSX" ++{ ++ HOST_WIDE_INT val = INTVAL (operands1); ++ if (val < 0) ++ { ++ HOST_WIDE_INT modeVal = (val & 0xf00) >> 8; ++ if (modeVal < 13) ++ return "vldi\t%w0,%1"; ++ else ++ sorry ("imm13 only support 0000 ~ 1100 in bits 9 ~ 12 when bit '13' is 1"); ++ return "#"; ++ } ++ else ++ return "vldi\t%w0,%1"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vshuf_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (unspec:V16QI (match_operand:V16QI 1 "register_operand" "f") ++ (match_operand:V16QI 2 "register_operand" "f") ++ (match_operand:V16QI 3 "register_operand" "f") ++ UNSPEC_LSX_VSHUF_B)) ++ "ISA_HAS_LSX" ++ "vshuf.b\t%w0,%w1,%w2,%w3" ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vldx" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (unspec:V16QI (match_operand:DI 1 "register_operand" "r") ++ (match_operand:DI 2 "reg_or_0_operand" "rJ") ++ UNSPEC_LSX_VLDX)) ++ "ISA_HAS_LSX" ++{ ++ return "vldx\t%w0,%1,%z2"; ++} ++ (set_attr "type" "simd_load") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vstx" ++ (set (mem:V16QI (plus:DI (match_operand:DI 1 "register_operand" "r") ++ (match_operand:DI 2 "reg_or_0_operand" "rJ"))) ++ (unspec: V16QI (match_operand:V16QI 0 "register_operand" "f") ++ UNSPEC_LSX_VSTX)) ++ ++ "ISA_HAS_LSX" ++{ ++ return "vstx\t%w0,%1,%z2"; ++} ++ (set_attr "type" "simd_store") ++ (set_attr "mode" "DI")) ++ ++(define_insn "lsx_vextl_qu_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ UNSPEC_LSX_VEXTL_QU_DU)) ++ "ISA_HAS_LSX" ++ "vextl.qu.du\t%w0,%w1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vseteqz_v" ++ (set (match_operand:FCC 0 "register_operand" "=z") ++ (eq:FCC ++ (unspec:SI (match_operand:V16QI 1 "register_operand" "f") ++ UNSPEC_LSX_VSETEQZ_V) ++ (match_operand:SI 2 "const_0_operand"))) ++ "ISA_HAS_LSX" ++{ ++ return "vseteqz.v\t%0,%1"; ++} ++ (set_attr "type" "simd_fcmp") ++ (set_attr "mode" "FCC")) ++ ++;; Vector reduction operation ++(define_expand "reduc_plus_scal_v2di" ++ (match_operand:DI 0 "register_operand") ++ (match_operand:V2DI 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (V2DImode); ++ emit_insn (gen_lsx_vhaddw_q_d (tmp, operands1, operands1)); ++ emit_insn (gen_vec_extractv2didi (operands0, tmp, const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_plus_scal_v4si" ++ (match_operand:SI 0 "register_operand") ++ (match_operand:V4SI 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (V2DImode); ++ rtx tmp1 = gen_reg_rtx (V2DImode); ++ emit_insn (gen_lsx_vhaddw_d_w (tmp, operands1, operands1)); ++ emit_insn (gen_lsx_vhaddw_q_d (tmp1, tmp, tmp)); ++ emit_insn (gen_vec_extractv4sisi (operands0, gen_lowpart (V4SImode,tmp1), ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_plus_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:FLSX 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_add<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_<optab>_scal_<mode>" ++ (any_bitwise:<UNITMODE> ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:ILSX 1 "register_operand")) ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_<optab><mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_smax_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:LSX 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_smax<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_smin_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:LSX 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_smin<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_umax_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:ILSX 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_umax<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_expand "reduc_umin_scal_<mode>" ++ (match_operand:<UNITMODE> 0 "register_operand") ++ (match_operand:ILSX 1 "register_operand") ++ "ISA_HAS_LSX" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ loongarch_expand_vector_reduc (gen_umin<mode>3, tmp, operands1); ++ emit_insn (gen_vec_extract<mode><unitmode> (operands0, tmp, ++ const0_rtx)); ++ DONE; ++}) ++ ++(define_insn "lsx_v<optab>wev_d_w<u>" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (addsubmul:V2DI ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2)))) ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wev.d.w<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_v<optab>wev_w_h<u>" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (addsubmul:V4SI ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wev.w.h<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_v<optab>wev_h_b<u>" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (addsubmul:V8HI ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wev.h.b<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_v<optab>wod_d_w<u>" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (addsubmul:V2DI ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3)))) ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wod.d.w<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_v<optab>wod_w_h<u>" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (addsubmul:V4SI ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wod.w.h<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_v<optab>wod_h_b<u>" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (addsubmul:V8HI ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wod.h.b<u>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_v<optab>wev_d_wu_w" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (addmul:V2DI ++ (zero_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2)))) ++ (sign_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wev.d.wu.w\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_v<optab>wev_w_hu_h" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (addmul:V4SI ++ (zero_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (sign_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wev.w.hu.h\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_v<optab>wev_h_bu_b" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (addmul:V8HI ++ (zero_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 1 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (sign_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wev.h.bu.b\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_v<optab>wod_d_wu_w" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (addmul:V2DI ++ (zero_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3)))) ++ (sign_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wod.d.wu.w\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_v<optab>wod_w_hu_h" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (addmul:V4SI ++ (zero_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (sign_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wod.w.hu.h\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_v<optab>wod_h_bu_b" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (addmul:V8HI ++ (zero_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 1 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (sign_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))))) ++ "ISA_HAS_LSX" ++ "v<optab>wod.h.bu.b\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vaddwev_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VADDWEV)) ++ "ISA_HAS_LSX" ++ "vaddwev.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vaddwev_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VADDWEV2)) ++ "ISA_HAS_LSX" ++ "vaddwev.q.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vaddwod_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VADDWOD)) ++ "ISA_HAS_LSX" ++ "vaddwod.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vaddwod_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VADDWOD2)) ++ "ISA_HAS_LSX" ++ "vaddwod.q.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vsubwev_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VSUBWEV)) ++ "ISA_HAS_LSX" ++ "vsubwev.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vsubwev_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VSUBWEV2)) ++ "ISA_HAS_LSX" ++ "vsubwev.q.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vsubwod_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VSUBWOD)) ++ "ISA_HAS_LSX" ++ "vsubwod.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vsubwod_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VSUBWOD2)) ++ "ISA_HAS_LSX" ++ "vsubwod.q.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vaddwev_q_du_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VADDWEV3)) ++ "ISA_HAS_LSX" ++ "vaddwev.q.du.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vaddwod_q_du_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VADDWOD3)) ++ "ISA_HAS_LSX" ++ "vaddwod.q.du.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmulwev_q_du_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VMULWEV3)) ++ "ISA_HAS_LSX" ++ "vmulwev.q.du.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmulwod_q_du_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VMULWOD3)) ++ "ISA_HAS_LSX" ++ "vmulwod.q.du.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmulwev_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VMULWEV)) ++ "ISA_HAS_LSX" ++ "vmulwev.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmulwev_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VMULWEV2)) ++ "ISA_HAS_LSX" ++ "vmulwev.q.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmulwod_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VMULWOD)) ++ "ISA_HAS_LSX" ++ "vmulwod.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmulwod_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VMULWOD2)) ++ "ISA_HAS_LSX" ++ "vmulwod.q.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vhaddw_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VHADDW_Q_D)) ++ "ISA_HAS_LSX" ++ "vhaddw.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vhaddw_qu_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VHADDW_QU_DU)) ++ "ISA_HAS_LSX" ++ "vhaddw.qu.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vhsubw_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VHSUBW_Q_D)) ++ "ISA_HAS_LSX" ++ "vhsubw.q.d\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vhsubw_qu_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VHSUBW_QU_DU)) ++ "ISA_HAS_LSX" ++ "vhsubw.qu.du\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwev_d_w<u>" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (plus:V2DI ++ (match_operand:V2DI 1 "register_operand" "0") ++ (mult:V2DI ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2)))) ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2))))))) ++ "ISA_HAS_LSX" ++ "vmaddwev.d.w<u>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwev_w_h<u>" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (plus:V4SI ++ (match_operand:V4SI 1 "register_operand" "0") ++ (mult:V4SI ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6))))))) ++ "ISA_HAS_LSX" ++ "vmaddwev.w.h<u>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vmaddwev_h_b<u>" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (plus:V8HI ++ (match_operand:V8HI 1 "register_operand" "0") ++ (mult:V8HI ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14))))))) ++ "ISA_HAS_LSX" ++ "vmaddwev.h.b<u>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vmaddwod_d_w<u>" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (plus:V2DI ++ (match_operand:V2DI 1 "register_operand" "0") ++ (mult:V2DI ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3)))) ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3))))))) ++ "ISA_HAS_LSX" ++ "vmaddwod.d.w<u>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwod_w_h<u>" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (plus:V4SI ++ (match_operand:V4SI 1 "register_operand" "0") ++ (mult:V4SI ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7))))))) ++ "ISA_HAS_LSX" ++ "vmaddwod.w.h<u>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vmaddwod_h_b<u>" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (plus:V8HI ++ (match_operand:V8HI 1 "register_operand" "0") ++ (mult:V8HI ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15))))))) ++ "ISA_HAS_LSX" ++ "vmaddwod.h.b<u>\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vmaddwev_d_wu_w" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (plus:V2DI ++ (match_operand:V2DI 1 "register_operand" "0") ++ (mult:V2DI ++ (zero_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2)))) ++ (sign_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2))))))) ++ "ISA_HAS_LSX" ++ "vmaddwev.d.wu.w\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwev_w_hu_h" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (plus:V4SI ++ (match_operand:V4SI 1 "register_operand" "0") ++ (mult:V4SI ++ (zero_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6)))) ++ (sign_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6))))))) ++ "ISA_HAS_LSX" ++ "vmaddwev.w.hu.h\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vmaddwev_h_bu_b" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (plus:V8HI ++ (match_operand:V8HI 1 "register_operand" "0") ++ (mult:V8HI ++ (zero_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "%f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14)))) ++ (sign_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 3 "register_operand" "f") ++ (parallel (const_int 0) (const_int 2) ++ (const_int 4) (const_int 6) ++ (const_int 8) (const_int 10) ++ (const_int 12) (const_int 14))))))) ++ "ISA_HAS_LSX" ++ "vmaddwev.h.bu.b\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vmaddwod_d_wu_w" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (plus:V2DI ++ (match_operand:V2DI 1 "register_operand" "0") ++ (mult:V2DI ++ (zero_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3)))) ++ (sign_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3))))))) ++ "ISA_HAS_LSX" ++ "vmaddwod.d.wu.w\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwod_w_hu_h" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (plus:V4SI ++ (match_operand:V4SI 1 "register_operand" "0") ++ (mult:V4SI ++ (zero_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7)))) ++ (sign_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7))))))) ++ "ISA_HAS_LSX" ++ "vmaddwod.w.hu.h\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vmaddwod_h_bu_b" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (plus:V8HI ++ (match_operand:V8HI 1 "register_operand" "0") ++ (mult:V8HI ++ (zero_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 2 "register_operand" "%f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15)))) ++ (sign_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 3 "register_operand" "f") ++ (parallel (const_int 1) (const_int 3) ++ (const_int 5) (const_int 7) ++ (const_int 9) (const_int 11) ++ (const_int 13) (const_int 15))))))) ++ "ISA_HAS_LSX" ++ "vmaddwod.h.bu.b\t%w0,%w2,%w3" ++ (set_attr "type" "simd_fmadd") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vmaddwev_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f") ++ (match_operand:V2DI 3 "register_operand" "f") ++ UNSPEC_LSX_VMADDWEV)) ++ "ISA_HAS_LSX" ++ "vmaddwev.q.d\t%w0,%w2,%w3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwod_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f") ++ (match_operand:V2DI 3 "register_operand" "f") ++ UNSPEC_LSX_VMADDWOD)) ++ "ISA_HAS_LSX" ++ "vmaddwod.q.d\t%w0,%w2,%w3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwev_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f") ++ (match_operand:V2DI 3 "register_operand" "f") ++ UNSPEC_LSX_VMADDWEV2)) ++ "ISA_HAS_LSX" ++ "vmaddwev.q.du\t%w0,%w2,%w3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwod_q_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f") ++ (match_operand:V2DI 3 "register_operand" "f") ++ UNSPEC_LSX_VMADDWOD2)) ++ "ISA_HAS_LSX" ++ "vmaddwod.q.du\t%w0,%w2,%w3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwev_q_du_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f") ++ (match_operand:V2DI 3 "register_operand" "f") ++ UNSPEC_LSX_VMADDWEV3)) ++ "ISA_HAS_LSX" ++ "vmaddwev.q.du.d\t%w0,%w2,%w3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmaddwod_q_du_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "0") ++ (match_operand:V2DI 2 "register_operand" "f") ++ (match_operand:V2DI 3 "register_operand" "f") ++ UNSPEC_LSX_VMADDWOD3)) ++ "ISA_HAS_LSX" ++ "vmaddwod.q.du.d\t%w0,%w2,%w3" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vrotr_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand:ILSX 2 "register_operand" "f") ++ UNSPEC_LSX_VROTR)) ++ "ISA_HAS_LSX" ++ "vrotr.<lsxfmt>\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vadd_q" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VADD_Q)) ++ "ISA_HAS_LSX" ++ "vadd.q\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vsub_q" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ (match_operand:V2DI 2 "register_operand" "f") ++ UNSPEC_LSX_VSUB_Q)) ++ "ISA_HAS_LSX" ++ "vsub.q\t%w0,%w1,%w2" ++ (set_attr "type" "simd_int_arith") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vmskgez_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (unspec:V16QI (match_operand:V16QI 1 "register_operand" "f") ++ UNSPEC_LSX_VMSKGEZ)) ++ "ISA_HAS_LSX" ++ "vmskgez.b\t%w0,%w1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vmsknz_b" ++ (set (match_operand:V16QI 0 "register_operand" "=f") ++ (unspec:V16QI (match_operand:V16QI 1 "register_operand" "f") ++ UNSPEC_LSX_VMSKNZ)) ++ "ISA_HAS_LSX" ++ "vmsknz.b\t%w0,%w1" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "V16QI")) ++ ++(define_insn "lsx_vexth_h<u>_b<u>" ++ (set (match_operand:V8HI 0 "register_operand" "=f") ++ (any_extend:V8HI ++ (vec_select:V8QI ++ (match_operand:V16QI 1 "register_operand" "f") ++ (parallel (const_int 8) (const_int 9) ++ (const_int 10) (const_int 11) ++ (const_int 12) (const_int 13) ++ (const_int 14) (const_int 15))))) ++ "ISA_HAS_LSX" ++ "vexth.h<u>.b<u>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V8HI")) ++ ++(define_insn "lsx_vexth_w<u>_h<u>" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (any_extend:V4SI ++ (vec_select:V4HI ++ (match_operand:V8HI 1 "register_operand" "f") ++ (parallel (const_int 4) (const_int 5) ++ (const_int 6) (const_int 7))))) ++ "ISA_HAS_LSX" ++ "vexth.w<u>.h<u>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V4SI")) ++ ++(define_insn "lsx_vexth_d<u>_w<u>" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (any_extend:V2DI ++ (vec_select:V2SI ++ (match_operand:V4SI 1 "register_operand" "f") ++ (parallel (const_int 2) (const_int 3))))) ++ "ISA_HAS_LSX" ++ "vexth.d<u>.w<u>\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vexth_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ UNSPEC_LSX_VEXTH_Q_D)) ++ "ISA_HAS_LSX" ++ "vexth.q.d\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vexth_qu_du" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ UNSPEC_LSX_VEXTH_QU_DU)) ++ "ISA_HAS_LSX" ++ "vexth.qu.du\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vrotri_<lsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (rotatert:ILSX (match_operand:ILSX 1 "register_operand" "f") ++ (match_operand 2 "const_<bitimm>_operand" ""))) ++ "ISA_HAS_LSX" ++ "vrotri.<lsxfmt>\t%w0,%w1,%2" ++ (set_attr "type" "simd_shf") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vextl_q_d" ++ (set (match_operand:V2DI 0 "register_operand" "=f") ++ (unspec:V2DI (match_operand:V2DI 1 "register_operand" "f") ++ UNSPEC_LSX_VEXTL_Q_D)) ++ "ISA_HAS_LSX" ++ "vextl.q.d\t%w0,%w1" ++ (set_attr "type" "simd_fcvt") ++ (set_attr "mode" "V2DI")) ++ ++(define_insn "lsx_vsrlni_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSRLNI)) ++ "ISA_HAS_LSX" ++ "vsrlni.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrlrni_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSRLRNI)) ++ "ISA_HAS_LSX" ++ "vsrlrni.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrlni_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRLNI)) ++ "ISA_HAS_LSX" ++ "vssrlni.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrlni_<lsxfmt_u>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRLNI2)) ++ "ISA_HAS_LSX" ++ "vssrlni.<lsxfmt_u>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrlrni_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRLRNI)) ++ "ISA_HAS_LSX" ++ "vssrlrni.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrlrni_<lsxfmt_u>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRLRNI2)) ++ "ISA_HAS_LSX" ++ "vssrlrni.<lsxfmt_u>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrani_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSRANI)) ++ "ISA_HAS_LSX" ++ "vsrani.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vsrarni_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSRARNI)) ++ "ISA_HAS_LSX" ++ "vsrarni.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrani_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRANI)) ++ "ISA_HAS_LSX" ++ "vssrani.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrani_<lsxfmt_u>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRANI2)) ++ "ISA_HAS_LSX" ++ "vssrani.<lsxfmt_u>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrarni_<lsxfmt>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRARNI)) ++ "ISA_HAS_LSX" ++ "vssrarni.<lsxfmt>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vssrarni_<lsxfmt_u>_<dlsxfmt>" ++ (set (match_operand:ILSX 0 "register_operand" "=f") ++ (unspec:ILSX (match_operand:ILSX 1 "register_operand" "0") ++ (match_operand:ILSX 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VSSRARNI2)) ++ "ISA_HAS_LSX" ++ "vssrarni.<lsxfmt_u>.<dlsxfmt>\t%w0,%w2,%3" ++ (set_attr "type" "simd_shift") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "lsx_vpermi_w" ++ (set (match_operand:V4SI 0 "register_operand" "=f") ++ (unspec:V4SI (match_operand:V4SI 1 "register_operand" "0") ++ (match_operand:V4SI 2 "register_operand" "f") ++ (match_operand 3 "const_uimm8_operand" "") ++ UNSPEC_LSX_VPERMI)) ++ "ISA_HAS_LSX" ++ "vpermi.w\t%w0,%w2,%3" ++ (set_attr "type" "simd_bit") ++ (set_attr "mode" "V4SI")) +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index 4966d5569..cf9361b73 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -87,10 +87,42 @@ + (and (match_code "const_int") + (match_test "IN_RANGE (INTVAL (op), 1, 4)"))) + ++(define_predicate "const_lsx_branch_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), -1024, 1023)"))) ++ ++(define_predicate "const_uimm3_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 7)"))) ++ ++(define_predicate "const_8_to_11_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 8, 11)"))) ++ ++(define_predicate "const_12_to_15_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 12, 15)"))) ++ ++(define_predicate "const_uimm4_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 15)"))) ++ + (define_predicate "const_uimm5_operand" + (and (match_code "const_int") + (match_test "IN_RANGE (INTVAL (op), 0, 31)"))) + ++(define_predicate "const_uimm6_operand" ++ (and (match_code "const_int") ++ (match_test "UIMM6_OPERAND (INTVAL (op))"))) ++ ++(define_predicate "const_uimm7_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 127)"))) ++ ++(define_predicate "const_uimm8_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 255)"))) ++ + (define_predicate "const_uimm14_operand" + (and (match_code "const_int") + (match_test "IN_RANGE (INTVAL (op), 0, 16383)"))) +@@ -99,10 +131,74 @@ + (and (match_code "const_int") + (match_test "IN_RANGE (INTVAL (op), 0, 32767)"))) + ++(define_predicate "const_imm5_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), -16, 15)"))) ++ ++(define_predicate "const_imm10_operand" ++ (and (match_code "const_int") ++ (match_test "IMM10_OPERAND (INTVAL (op))"))) ++ + (define_predicate "const_imm12_operand" + (and (match_code "const_int") + (match_test "IMM12_OPERAND (INTVAL (op))"))) + ++(define_predicate "const_imm13_operand" ++ (and (match_code "const_int") ++ (match_test "IMM13_OPERAND (INTVAL (op))"))) ++ ++(define_predicate "reg_imm10_operand" ++ (ior (match_operand 0 "const_imm10_operand") ++ (match_operand 0 "register_operand"))) ++ ++(define_predicate "aq8b_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 8, 0)"))) ++ ++(define_predicate "aq8h_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 8, 1)"))) ++ ++(define_predicate "aq8w_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 8, 2)"))) ++ ++(define_predicate "aq8d_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 8, 3)"))) ++ ++(define_predicate "aq10b_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 10, 0)"))) ++ ++(define_predicate "aq10h_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 10, 1)"))) ++ ++(define_predicate "aq10w_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 10, 2)"))) ++ ++(define_predicate "aq10d_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 10, 3)"))) ++ ++(define_predicate "aq12b_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 12, 0)"))) ++ ++(define_predicate "aq12h_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 11, 1)"))) ++ ++(define_predicate "aq12w_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 10, 2)"))) ++ ++(define_predicate "aq12d_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 9, 3)"))) ++ + (define_predicate "sle_operand" + (and (match_code "const_int") + (match_test "IMM12_OPERAND (INTVAL (op) + 1)"))) +@@ -112,29 +208,206 @@ + (match_test "INTVAL (op) + 1 != 0"))) + + (define_predicate "const_0_operand" +- (and (match_code "const_int,const_double,const_vector") ++ (and (match_code "const_int,const_wide_int,const_double,const_vector") + (match_test "op == CONST0_RTX (GET_MODE (op))"))) + ++(define_predicate "const_m1_operand" ++ (and (match_code "const_int,const_wide_int,const_double,const_vector") ++ (match_test "op == CONSTM1_RTX (GET_MODE (op))"))) ++ ++(define_predicate "reg_or_m1_operand" ++ (ior (match_operand 0 "const_m1_operand") ++ (match_operand 0 "register_operand"))) ++ + (define_predicate "reg_or_0_operand" + (ior (match_operand 0 "const_0_operand") + (match_operand 0 "register_operand"))) + + (define_predicate "const_1_operand" +- (and (match_code "const_int,const_double,const_vector") ++ (and (match_code "const_int,const_wide_int,const_double,const_vector") + (match_test "op == CONST1_RTX (GET_MODE (op))"))) + + (define_predicate "reg_or_1_operand" + (ior (match_operand 0 "const_1_operand") + (match_operand 0 "register_operand"))) + ++;; These are used in vec_merge, hence accept bitmask as const_int. ++(define_predicate "const_exp_2_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (exact_log2 (INTVAL (op)), 0, 1)"))) ++ ++(define_predicate "const_exp_4_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (exact_log2 (INTVAL (op)), 0, 3)"))) ++ ++(define_predicate "const_exp_8_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (exact_log2 (INTVAL (op)), 0, 7)"))) ++ ++(define_predicate "const_exp_16_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (exact_log2 (INTVAL (op)), 0, 15)"))) ++ ++(define_predicate "const_exp_32_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (exact_log2 (INTVAL (op)), 0, 31)"))) ++ ++;; This is used for indexing into vectors, and hence only accepts const_int. ++(define_predicate "const_0_or_1_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 1)"))) ++ ++(define_predicate "const_0_to_3_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 3)"))) ++ ++(define_predicate "const_0_to_7_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 7)"))) ++ ++(define_predicate "const_2_or_3_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 2, 3)"))) ++ ++(define_predicate "const_4_to_7_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 4, 7)"))) ++ ++(define_predicate "const_8_to_15_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 7)"))) ++ ++(define_predicate "const_16_to_31_operand" ++ (and (match_code "const_int") ++ (match_test "IN_RANGE (INTVAL (op), 0, 7)"))) ++ ++(define_predicate "qi_mask_operand" ++ (and (match_code "const_int") ++ (match_test "UINTVAL (op) == 0xff"))) ++ ++(define_predicate "hi_mask_operand" ++ (and (match_code "const_int") ++ (match_test "UINTVAL (op) == 0xffff"))) ++ + (define_predicate "lu52i_mask_operand" + (and (match_code "const_int") + (match_test "UINTVAL (op) == 0xfffffffffffff"))) + ++(define_predicate "si_mask_operand" ++ (and (match_code "const_int") ++ (match_test "UINTVAL (op) == 0xffffffff"))) ++ + (define_predicate "low_bitmask_operand" + (and (match_code "const_int") + (match_test "low_bitmask_len (mode, INTVAL (op)) > 12"))) + ++(define_predicate "d_operand" ++ (and (match_code "reg") ++ (match_test "GP_REG_P (REGNO (op))"))) ++ ++(define_predicate "db4_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op) + 1, 4, 0)"))) ++ ++(define_predicate "db7_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op) + 1, 7, 0)"))) ++ ++(define_predicate "db8_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op) + 1, 8, 0)"))) ++ ++(define_predicate "ib3_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op) - 1, 3, 0)"))) ++ ++(define_predicate "sb4_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 4, 0)"))) ++ ++(define_predicate "sb5_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 5, 0)"))) ++ ++(define_predicate "sb8_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 8, 0)"))) ++ ++(define_predicate "sd8_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_signed_immediate_p (INTVAL (op), 8, 3)"))) ++ ++(define_predicate "ub4_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op), 4, 0)"))) ++ ++(define_predicate "ub8_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op), 8, 0)"))) ++ ++(define_predicate "uh4_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op), 4, 1)"))) ++ ++(define_predicate "uw4_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op), 4, 2)"))) ++ ++(define_predicate "uw5_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op), 5, 2)"))) ++ ++(define_predicate "uw6_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op), 6, 2)"))) ++ ++(define_predicate "uw8_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_unsigned_immediate_p (INTVAL (op), 8, 2)"))) ++ ++(define_predicate "addiur2_operand" ++ (and (match_code "const_int") ++ (ior (match_test "INTVAL (op) == -1") ++ (match_test "INTVAL (op) == 1") ++ (match_test "INTVAL (op) == 4") ++ (match_test "INTVAL (op) == 8") ++ (match_test "INTVAL (op) == 12") ++ (match_test "INTVAL (op) == 16") ++ (match_test "INTVAL (op) == 20") ++ (match_test "INTVAL (op) == 24")))) ++ ++(define_predicate "addiusp_operand" ++ (and (match_code "const_int") ++ (ior (match_test "(IN_RANGE (INTVAL (op), 2, 257))") ++ (match_test "(IN_RANGE (INTVAL (op), -258, -3))")))) ++ ++(define_predicate "andi16_operand" ++ (and (match_code "const_int") ++ (ior (match_test "IN_RANGE (INTVAL (op), 1, 4)") ++ (match_test "IN_RANGE (INTVAL (op), 7, 8)") ++ (match_test "IN_RANGE (INTVAL (op), 15, 16)") ++ (match_test "IN_RANGE (INTVAL (op), 31, 32)") ++ (match_test "IN_RANGE (INTVAL (op), 63, 64)") ++ (match_test "INTVAL (op) == 255") ++ (match_test "INTVAL (op) == 32768") ++ (match_test "INTVAL (op) == 65535")))) ++ ++(define_predicate "movep_src_register" ++ (and (match_code "reg") ++ (ior (match_test ("IN_RANGE (REGNO (op), 2, 3)")) ++ (match_test ("IN_RANGE (REGNO (op), 16, 20)"))))) ++ ++(define_predicate "movep_src_operand" ++ (ior (match_operand 0 "const_0_operand") ++ (match_operand 0 "movep_src_register"))) ++ ++(define_predicate "fcc_reload_operand" ++ (and (match_code "reg,subreg") ++ (match_test "FCC_REG_P (true_regnum (op))"))) ++ ++(define_predicate "muldiv_target_operand" ++ (match_operand 0 "register_operand")) ++ + (define_predicate "const_call_insn_operand" + (match_code "const,symbol_ref,label_ref") + { +@@ -303,3 +576,59 @@ + (define_predicate "non_volatile_mem_operand" + (and (match_operand 0 "memory_operand") + (not (match_test "MEM_VOLATILE_P (op)")))) ++ ++(define_predicate "const_vector_same_val_operand" ++ (match_code "const_vector") ++{ ++ return loongarch_const_vector_same_val_p (op, mode); ++}) ++ ++(define_predicate "const_vector_same_simm5_operand" ++ (match_code "const_vector") ++{ ++ return loongarch_const_vector_same_int_p (op, mode, -16, 15); ++}) ++ ++(define_predicate "const_vector_same_uimm5_operand" ++ (match_code "const_vector") ++{ ++ return loongarch_const_vector_same_int_p (op, mode, 0, 31); ++}) ++ ++(define_predicate "const_vector_same_ximm5_operand" ++ (match_code "const_vector") ++{ ++ return loongarch_const_vector_same_int_p (op, mode, -31, 31); ++}) ++ ++(define_predicate "const_vector_same_uimm6_operand" ++ (match_code "const_vector") ++{ ++ return loongarch_const_vector_same_int_p (op, mode, 0, 63); ++}) ++ ++(define_predicate "par_const_vector_shf_set_operand" ++ (match_code "parallel") ++{ ++ return loongarch_const_vector_shuffle_set_p (op, mode); ++}) ++ ++(define_predicate "reg_or_vector_same_val_operand" ++ (ior (match_operand 0 "register_operand") ++ (match_operand 0 "const_vector_same_val_operand"))) ++ ++(define_predicate "reg_or_vector_same_simm5_operand" ++ (ior (match_operand 0 "register_operand") ++ (match_operand 0 "const_vector_same_simm5_operand"))) ++ ++(define_predicate "reg_or_vector_same_uimm5_operand" ++ (ior (match_operand 0 "register_operand") ++ (match_operand 0 "const_vector_same_uimm5_operand"))) ++ ++(define_predicate "reg_or_vector_same_ximm5_operand" ++ (ior (match_operand 0 "register_operand") ++ (match_operand 0 "const_vector_same_ximm5_operand"))) ++ ++(define_predicate "reg_or_vector_same_uimm6_operand" ++ (ior (match_operand 0 "register_operand") ++ (match_operand 0 "const_vector_same_uimm6_operand"))) +diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi +index 3b544358b..b58da0787 100644 +--- a/gcc/doc/md.texi ++++ b/gcc/doc/md.texi +@@ -2764,6 +2764,17 @@ as @code{st.w} and @code{ld.w}. + A signed 12-bit constant (for arithmetic instructions). + @item K + An unsigned 12-bit constant (for logic instructions). ++@item M ++A constant that cannot be loaded using @code{lui}, @code{addiu} ++or @code{ori}. ++@item N ++A constant in the range -65535 to -1 (inclusive). ++@item O ++A signed 15-bit constant. ++@item P ++A constant in the range 1 to 65535 (inclusive). ++@item R ++An address that can be used in a non-macro load or store. + @item ZB + An address that is held in a general-purpose register. + The offset is zero. +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-Loongson-SX-directive-builtin-function.patch
Added
@@ -0,0 +1,7549 @@ +From aafa5ab8c53dd2919d417b2f47e0c0e63ca7e10d Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 16 Mar 2023 16:31:04 +0800 +Subject: PATCH 064/124 LoongArch: Add Loongson SX directive builtin function + support. + +gcc/ChangeLog: + + * config.gcc: Export the header file lsxintrin.h. + * config/loongarch/loongarch-builtins.cc (LARCH_FTYPE_NAME4): Add builtin function support. + (enum loongarch_builtin_type): Ditto. + (AVAIL_ALL): Ditto. + (LARCH_BUILTIN): Ditto. + (LSX_BUILTIN): Ditto. + (LSX_BUILTIN_TEST_BRANCH): Ditto. + (LSX_NO_TARGET_BUILTIN): Ditto. + (CODE_FOR_lsx_vsadd_b): Ditto. + (CODE_FOR_lsx_vsadd_h): Ditto. + (CODE_FOR_lsx_vsadd_w): Ditto. + (CODE_FOR_lsx_vsadd_d): Ditto. + (CODE_FOR_lsx_vsadd_bu): Ditto. + (CODE_FOR_lsx_vsadd_hu): Ditto. + (CODE_FOR_lsx_vsadd_wu): Ditto. + (CODE_FOR_lsx_vsadd_du): Ditto. + (CODE_FOR_lsx_vadd_b): Ditto. + (CODE_FOR_lsx_vadd_h): Ditto. + (CODE_FOR_lsx_vadd_w): Ditto. + (CODE_FOR_lsx_vadd_d): Ditto. + (CODE_FOR_lsx_vaddi_bu): Ditto. + (CODE_FOR_lsx_vaddi_hu): Ditto. + (CODE_FOR_lsx_vaddi_wu): Ditto. + (CODE_FOR_lsx_vaddi_du): Ditto. + (CODE_FOR_lsx_vand_v): Ditto. + (CODE_FOR_lsx_vandi_b): Ditto. + (CODE_FOR_lsx_bnz_v): Ditto. + (CODE_FOR_lsx_bz_v): Ditto. + (CODE_FOR_lsx_vbitsel_v): Ditto. + (CODE_FOR_lsx_vseqi_b): Ditto. + (CODE_FOR_lsx_vseqi_h): Ditto. + (CODE_FOR_lsx_vseqi_w): Ditto. + (CODE_FOR_lsx_vseqi_d): Ditto. + (CODE_FOR_lsx_vslti_b): Ditto. + (CODE_FOR_lsx_vslti_h): Ditto. + (CODE_FOR_lsx_vslti_w): Ditto. + (CODE_FOR_lsx_vslti_d): Ditto. + (CODE_FOR_lsx_vslti_bu): Ditto. + (CODE_FOR_lsx_vslti_hu): Ditto. + (CODE_FOR_lsx_vslti_wu): Ditto. + (CODE_FOR_lsx_vslti_du): Ditto. + (CODE_FOR_lsx_vslei_b): Ditto. + (CODE_FOR_lsx_vslei_h): Ditto. + (CODE_FOR_lsx_vslei_w): Ditto. + (CODE_FOR_lsx_vslei_d): Ditto. + (CODE_FOR_lsx_vslei_bu): Ditto. + (CODE_FOR_lsx_vslei_hu): Ditto. + (CODE_FOR_lsx_vslei_wu): Ditto. + (CODE_FOR_lsx_vslei_du): Ditto. + (CODE_FOR_lsx_vdiv_b): Ditto. + (CODE_FOR_lsx_vdiv_h): Ditto. + (CODE_FOR_lsx_vdiv_w): Ditto. + (CODE_FOR_lsx_vdiv_d): Ditto. + (CODE_FOR_lsx_vdiv_bu): Ditto. + (CODE_FOR_lsx_vdiv_hu): Ditto. + (CODE_FOR_lsx_vdiv_wu): Ditto. + (CODE_FOR_lsx_vdiv_du): Ditto. + (CODE_FOR_lsx_vfadd_s): Ditto. + (CODE_FOR_lsx_vfadd_d): Ditto. + (CODE_FOR_lsx_vftintrz_w_s): Ditto. + (CODE_FOR_lsx_vftintrz_l_d): Ditto. + (CODE_FOR_lsx_vftintrz_wu_s): Ditto. + (CODE_FOR_lsx_vftintrz_lu_d): Ditto. + (CODE_FOR_lsx_vffint_s_w): Ditto. + (CODE_FOR_lsx_vffint_d_l): Ditto. + (CODE_FOR_lsx_vffint_s_wu): Ditto. + (CODE_FOR_lsx_vffint_d_lu): Ditto. + (CODE_FOR_lsx_vfsub_s): Ditto. + (CODE_FOR_lsx_vfsub_d): Ditto. + (CODE_FOR_lsx_vfmul_s): Ditto. + (CODE_FOR_lsx_vfmul_d): Ditto. + (CODE_FOR_lsx_vfdiv_s): Ditto. + (CODE_FOR_lsx_vfdiv_d): Ditto. + (CODE_FOR_lsx_vfmax_s): Ditto. + (CODE_FOR_lsx_vfmax_d): Ditto. + (CODE_FOR_lsx_vfmin_s): Ditto. + (CODE_FOR_lsx_vfmin_d): Ditto. + (CODE_FOR_lsx_vfsqrt_s): Ditto. + (CODE_FOR_lsx_vfsqrt_d): Ditto. + (CODE_FOR_lsx_vflogb_s): Ditto. + (CODE_FOR_lsx_vflogb_d): Ditto. + (CODE_FOR_lsx_vmax_b): Ditto. + (CODE_FOR_lsx_vmax_h): Ditto. + (CODE_FOR_lsx_vmax_w): Ditto. + (CODE_FOR_lsx_vmax_d): Ditto. + (CODE_FOR_lsx_vmaxi_b): Ditto. + (CODE_FOR_lsx_vmaxi_h): Ditto. + (CODE_FOR_lsx_vmaxi_w): Ditto. + (CODE_FOR_lsx_vmaxi_d): Ditto. + (CODE_FOR_lsx_vmax_bu): Ditto. + (CODE_FOR_lsx_vmax_hu): Ditto. + (CODE_FOR_lsx_vmax_wu): Ditto. + (CODE_FOR_lsx_vmax_du): Ditto. + (CODE_FOR_lsx_vmaxi_bu): Ditto. + (CODE_FOR_lsx_vmaxi_hu): Ditto. + (CODE_FOR_lsx_vmaxi_wu): Ditto. + (CODE_FOR_lsx_vmaxi_du): Ditto. + (CODE_FOR_lsx_vmin_b): Ditto. + (CODE_FOR_lsx_vmin_h): Ditto. + (CODE_FOR_lsx_vmin_w): Ditto. + (CODE_FOR_lsx_vmin_d): Ditto. + (CODE_FOR_lsx_vmini_b): Ditto. + (CODE_FOR_lsx_vmini_h): Ditto. + (CODE_FOR_lsx_vmini_w): Ditto. + (CODE_FOR_lsx_vmini_d): Ditto. + (CODE_FOR_lsx_vmin_bu): Ditto. + (CODE_FOR_lsx_vmin_hu): Ditto. + (CODE_FOR_lsx_vmin_wu): Ditto. + (CODE_FOR_lsx_vmin_du): Ditto. + (CODE_FOR_lsx_vmini_bu): Ditto. + (CODE_FOR_lsx_vmini_hu): Ditto. + (CODE_FOR_lsx_vmini_wu): Ditto. + (CODE_FOR_lsx_vmini_du): Ditto. + (CODE_FOR_lsx_vmod_b): Ditto. + (CODE_FOR_lsx_vmod_h): Ditto. + (CODE_FOR_lsx_vmod_w): Ditto. + (CODE_FOR_lsx_vmod_d): Ditto. + (CODE_FOR_lsx_vmod_bu): Ditto. + (CODE_FOR_lsx_vmod_hu): Ditto. + (CODE_FOR_lsx_vmod_wu): Ditto. + (CODE_FOR_lsx_vmod_du): Ditto. + (CODE_FOR_lsx_vmul_b): Ditto. + (CODE_FOR_lsx_vmul_h): Ditto. + (CODE_FOR_lsx_vmul_w): Ditto. + (CODE_FOR_lsx_vmul_d): Ditto. + (CODE_FOR_lsx_vclz_b): Ditto. + (CODE_FOR_lsx_vclz_h): Ditto. + (CODE_FOR_lsx_vclz_w): Ditto. + (CODE_FOR_lsx_vclz_d): Ditto. + (CODE_FOR_lsx_vnor_v): Ditto. + (CODE_FOR_lsx_vor_v): Ditto. + (CODE_FOR_lsx_vori_b): Ditto. + (CODE_FOR_lsx_vnori_b): Ditto. + (CODE_FOR_lsx_vpcnt_b): Ditto. + (CODE_FOR_lsx_vpcnt_h): Ditto. + (CODE_FOR_lsx_vpcnt_w): Ditto. + (CODE_FOR_lsx_vpcnt_d): Ditto. + (CODE_FOR_lsx_vxor_v): Ditto. + (CODE_FOR_lsx_vxori_b): Ditto. + (CODE_FOR_lsx_vsll_b): Ditto. + (CODE_FOR_lsx_vsll_h): Ditto. + (CODE_FOR_lsx_vsll_w): Ditto. + (CODE_FOR_lsx_vsll_d): Ditto. + (CODE_FOR_lsx_vslli_b): Ditto. + (CODE_FOR_lsx_vslli_h): Ditto. + (CODE_FOR_lsx_vslli_w): Ditto. + (CODE_FOR_lsx_vslli_d): Ditto. + (CODE_FOR_lsx_vsra_b): Ditto. + (CODE_FOR_lsx_vsra_h): Ditto. + (CODE_FOR_lsx_vsra_w): Ditto. + (CODE_FOR_lsx_vsra_d): Ditto. + (CODE_FOR_lsx_vsrai_b): Ditto. + (CODE_FOR_lsx_vsrai_h): Ditto. + (CODE_FOR_lsx_vsrai_w): Ditto. + (CODE_FOR_lsx_vsrai_d): Ditto. + (CODE_FOR_lsx_vsrl_b): Ditto. + (CODE_FOR_lsx_vsrl_h): Ditto. + (CODE_FOR_lsx_vsrl_w): Ditto. + (CODE_FOR_lsx_vsrl_d): Ditto. + (CODE_FOR_lsx_vsrli_b): Ditto. + (CODE_FOR_lsx_vsrli_h): Ditto. + (CODE_FOR_lsx_vsrli_w): Ditto. + (CODE_FOR_lsx_vsrli_d): Ditto. + (CODE_FOR_lsx_vsub_b): Ditto. + (CODE_FOR_lsx_vsub_h): Ditto. + (CODE_FOR_lsx_vsub_w): Ditto. + (CODE_FOR_lsx_vsub_d): Ditto. + (CODE_FOR_lsx_vsubi_bu): Ditto. + (CODE_FOR_lsx_vsubi_hu): Ditto. + (CODE_FOR_lsx_vsubi_wu): Ditto. + (CODE_FOR_lsx_vsubi_du): Ditto. + (CODE_FOR_lsx_vpackod_d): Ditto. + (CODE_FOR_lsx_vpackev_d): Ditto. + (CODE_FOR_lsx_vpickod_d): Ditto. + (CODE_FOR_lsx_vpickev_d): Ditto. + (CODE_FOR_lsx_vrepli_b): Ditto. + (CODE_FOR_lsx_vrepli_h): Ditto. + (CODE_FOR_lsx_vrepli_w): Ditto. + (CODE_FOR_lsx_vrepli_d): Ditto. + (CODE_FOR_lsx_vsat_b): Ditto. + (CODE_FOR_lsx_vsat_h): Ditto. + (CODE_FOR_lsx_vsat_w): Ditto. + (CODE_FOR_lsx_vsat_d): Ditto. + (CODE_FOR_lsx_vsat_bu): Ditto. + (CODE_FOR_lsx_vsat_hu): Ditto. + (CODE_FOR_lsx_vsat_wu): Ditto. + (CODE_FOR_lsx_vsat_du): Ditto. + (CODE_FOR_lsx_vavg_b): Ditto. + (CODE_FOR_lsx_vavg_h): Ditto. + (CODE_FOR_lsx_vavg_w): Ditto. + (CODE_FOR_lsx_vavg_d): Ditto. + (CODE_FOR_lsx_vavg_bu): Ditto. + (CODE_FOR_lsx_vavg_hu): Ditto. + (CODE_FOR_lsx_vavg_wu): Ditto. + (CODE_FOR_lsx_vavg_du): Ditto. + (CODE_FOR_lsx_vavgr_b): Ditto. + (CODE_FOR_lsx_vavgr_h): Ditto. + (CODE_FOR_lsx_vavgr_w): Ditto. + (CODE_FOR_lsx_vavgr_d): Ditto. + (CODE_FOR_lsx_vavgr_bu): Ditto. + (CODE_FOR_lsx_vavgr_hu): Ditto. + (CODE_FOR_lsx_vavgr_wu): Ditto. + (CODE_FOR_lsx_vavgr_du): Ditto. + (CODE_FOR_lsx_vssub_b): Ditto. + (CODE_FOR_lsx_vssub_h): Ditto. + (CODE_FOR_lsx_vssub_w): Ditto. + (CODE_FOR_lsx_vssub_d): Ditto. + (CODE_FOR_lsx_vssub_bu): Ditto. + (CODE_FOR_lsx_vssub_hu): Ditto. + (CODE_FOR_lsx_vssub_wu): Ditto. + (CODE_FOR_lsx_vssub_du): Ditto. + (CODE_FOR_lsx_vabsd_b): Ditto. + (CODE_FOR_lsx_vabsd_h): Ditto. + (CODE_FOR_lsx_vabsd_w): Ditto. + (CODE_FOR_lsx_vabsd_d): Ditto. + (CODE_FOR_lsx_vabsd_bu): Ditto. + (CODE_FOR_lsx_vabsd_hu): Ditto. + (CODE_FOR_lsx_vabsd_wu): Ditto. + (CODE_FOR_lsx_vabsd_du): Ditto. + (CODE_FOR_lsx_vftint_w_s): Ditto. + (CODE_FOR_lsx_vftint_l_d): Ditto. + (CODE_FOR_lsx_vftint_wu_s): Ditto. + (CODE_FOR_lsx_vftint_lu_d): Ditto. + (CODE_FOR_lsx_vandn_v): Ditto. + (CODE_FOR_lsx_vorn_v): Ditto. + (CODE_FOR_lsx_vneg_b): Ditto. + (CODE_FOR_lsx_vneg_h): Ditto. + (CODE_FOR_lsx_vneg_w): Ditto. + (CODE_FOR_lsx_vneg_d): Ditto. + (CODE_FOR_lsx_vshuf4i_d): Ditto. + (CODE_FOR_lsx_vbsrl_v): Ditto. + (CODE_FOR_lsx_vbsll_v): Ditto. + (CODE_FOR_lsx_vfmadd_s): Ditto. + (CODE_FOR_lsx_vfmadd_d): Ditto. + (CODE_FOR_lsx_vfmsub_s): Ditto. + (CODE_FOR_lsx_vfmsub_d): Ditto. + (CODE_FOR_lsx_vfnmadd_s): Ditto. + (CODE_FOR_lsx_vfnmadd_d): Ditto. + (CODE_FOR_lsx_vfnmsub_s): Ditto. + (CODE_FOR_lsx_vfnmsub_d): Ditto. + (CODE_FOR_lsx_vmuh_b): Ditto. + (CODE_FOR_lsx_vmuh_h): Ditto. + (CODE_FOR_lsx_vmuh_w): Ditto. + (CODE_FOR_lsx_vmuh_d): Ditto. + (CODE_FOR_lsx_vmuh_bu): Ditto. + (CODE_FOR_lsx_vmuh_hu): Ditto. + (CODE_FOR_lsx_vmuh_wu): Ditto. + (CODE_FOR_lsx_vmuh_du): Ditto. + (CODE_FOR_lsx_vsllwil_h_b): Ditto. + (CODE_FOR_lsx_vsllwil_w_h): Ditto. + (CODE_FOR_lsx_vsllwil_d_w): Ditto. + (CODE_FOR_lsx_vsllwil_hu_bu): Ditto. + (CODE_FOR_lsx_vsllwil_wu_hu): Ditto. + (CODE_FOR_lsx_vsllwil_du_wu): Ditto. + (CODE_FOR_lsx_vssran_b_h): Ditto. + (CODE_FOR_lsx_vssran_h_w): Ditto. + (CODE_FOR_lsx_vssran_w_d): Ditto. + (CODE_FOR_lsx_vssran_bu_h): Ditto. + (CODE_FOR_lsx_vssran_hu_w): Ditto. + (CODE_FOR_lsx_vssran_wu_d): Ditto. + (CODE_FOR_lsx_vssrarn_b_h): Ditto. + (CODE_FOR_lsx_vssrarn_h_w): Ditto. + (CODE_FOR_lsx_vssrarn_w_d): Ditto. + (CODE_FOR_lsx_vssrarn_bu_h): Ditto. + (CODE_FOR_lsx_vssrarn_hu_w): Ditto. + (CODE_FOR_lsx_vssrarn_wu_d): Ditto. + (CODE_FOR_lsx_vssrln_bu_h): Ditto. + (CODE_FOR_lsx_vssrln_hu_w): Ditto. + (CODE_FOR_lsx_vssrln_wu_d): Ditto. + (CODE_FOR_lsx_vssrlrn_bu_h): Ditto. + (CODE_FOR_lsx_vssrlrn_hu_w): Ditto. + (CODE_FOR_lsx_vssrlrn_wu_d): Ditto. + (loongarch_builtin_vector_type): Ditto. + (loongarch_build_cvpointer_type): Ditto. + (LARCH_ATYPE_CVPOINTER): Ditto. + (LARCH_ATYPE_BOOLEAN): Ditto. + (LARCH_ATYPE_V2SF): Ditto. + (LARCH_ATYPE_V2HI): Ditto. + (LARCH_ATYPE_V2SI): Ditto. + (LARCH_ATYPE_V4QI): Ditto. + (LARCH_ATYPE_V4HI): Ditto. + (LARCH_ATYPE_V8QI): Ditto. + (LARCH_ATYPE_V2DI): Ditto. + (LARCH_ATYPE_V4SI): Ditto. + (LARCH_ATYPE_V8HI): Ditto. + (LARCH_ATYPE_V16QI): Ditto. + (LARCH_ATYPE_V2DF): Ditto. + (LARCH_ATYPE_V4SF): Ditto. + (LARCH_ATYPE_V4DI): Ditto. + (LARCH_ATYPE_V8SI): Ditto. + (LARCH_ATYPE_V16HI): Ditto. + (LARCH_ATYPE_V32QI): Ditto. + (LARCH_ATYPE_V4DF): Ditto. + (LARCH_ATYPE_V8SF): Ditto. + (LARCH_ATYPE_UV2DI): Ditto. + (LARCH_ATYPE_UV4SI): Ditto. + (LARCH_ATYPE_UV8HI): Ditto. + (LARCH_ATYPE_UV16QI): Ditto. + (LARCH_ATYPE_UV4DI): Ditto. + (LARCH_ATYPE_UV8SI): Ditto. + (LARCH_ATYPE_UV16HI): Ditto. + (LARCH_ATYPE_UV32QI): Ditto. + (LARCH_ATYPE_UV2SI): Ditto. + (LARCH_ATYPE_UV4HI): Ditto. + (LARCH_ATYPE_UV8QI): Ditto. + (loongarch_builtin_vectorized_function): Ditto. + (LARCH_GET_BUILTIN): Ditto. + (loongarch_expand_builtin_insn): Ditto. + (loongarch_expand_builtin_lsx_test_branch): Ditto. + (loongarch_expand_builtin): Ditto. + * config/loongarch/loongarch-ftypes.def (1): Ditto. + (2): Ditto. + (3): Ditto. + (4): Ditto. + * config/loongarch/lsxintrin.h: New file. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config.gcc | 2 +- + gcc/config/loongarch/loongarch-builtins.cc | 1498 +++++- + gcc/config/loongarch/loongarch-ftypes.def | 395 +- + gcc/config/loongarch/lsxintrin.h | 5181 ++++++++++++++++++++ + 4 files changed, 7070 insertions(+), 6 deletions(-) + create mode 100644 gcc/config/loongarch/lsxintrin.h + +diff --git a/gcc/config.gcc b/gcc/config.gcc +index 61d81d8d8..4e149e0ef 100644 +--- a/gcc/config.gcc ++++ b/gcc/config.gcc +@@ -456,7 +456,7 @@ mips*-*-*) + ;; + loongarch*-*-*) + cpu_type=loongarch +- extra_headers="larchintrin.h" ++ extra_headers="larchintrin.h lsxintrin.h" + extra_objs="loongarch-c.o loongarch-builtins.o loongarch-cpu.o loongarch-opts.o loongarch-def.o" + extra_gcc_objs="loongarch-driver.o loongarch-cpu.o loongarch-opts.o loongarch-def.o" + extra_options="${extra_options} g.opt fused-madd.opt" +diff --git a/gcc/config/loongarch/loongarch-builtins.cc b/gcc/config/loongarch/loongarch-builtins.cc +index c8548a07f..de6428ac6 100644 +--- a/gcc/config/loongarch/loongarch-builtins.cc ++++ b/gcc/config/loongarch/loongarch-builtins.cc +@@ -34,14 +34,18 @@ along with GCC; see the file COPYING3. If not see + #include "recog.h" + #include "diagnostic.h" + #include "fold-const.h" ++#include "explow.h" + #include "expr.h" + #include "langhooks.h" + #include "emit-rtl.h" ++#include "case-cfn-macros.h" + + /* Macros to create an enumeration identifier for a function prototype. */ + #define LARCH_FTYPE_NAME1(A, B) LARCH_##A##_FTYPE_##B + #define LARCH_FTYPE_NAME2(A, B, C) LARCH_##A##_FTYPE_##B##_##C + #define LARCH_FTYPE_NAME3(A, B, C, D) LARCH_##A##_FTYPE_##B##_##C##_##D ++#define LARCH_FTYPE_NAME4(A, B, C, D, E) \ ++ LARCH_##A##_FTYPE_##B##_##C##_##D##_##E + + /* Classifies the prototype of a built-in function. */ + enum loongarch_function_type +@@ -64,6 +68,12 @@ enum loongarch_builtin_type + value and the arguments are mapped to operands 0 and above. */ + LARCH_BUILTIN_DIRECT_NO_TARGET, + ++ /* For generating LoongArch LSX. */ ++ LARCH_BUILTIN_LSX, ++ ++ /* The function corresponds to an LSX conditional branch instruction ++ combined with a compare instruction. */ ++ LARCH_BUILTIN_LSX_TEST_BRANCH, + }; + + /* Declare an availability predicate for built-in functions that require +@@ -101,6 +111,7 @@ struct loongarch_builtin_description + }; + + AVAIL_ALL (hard_float, TARGET_HARD_FLOAT_ABI) ++AVAIL_ALL (lsx, ISA_HAS_LSX) + + /* Construct a loongarch_builtin_description from the given arguments. + +@@ -120,8 +131,8 @@ AVAIL_ALL (hard_float, TARGET_HARD_FLOAT_ABI) + #define LARCH_BUILTIN(INSN, NAME, BUILTIN_TYPE, FUNCTION_TYPE, AVAIL) \ + { \ + CODE_FOR_loongarch_##INSN, "__builtin_loongarch_" NAME, \ +- BUILTIN_TYPE, FUNCTION_TYPE, \ +- loongarch_builtin_avail_##AVAIL \ ++ BUILTIN_TYPE, FUNCTION_TYPE, \ ++ loongarch_builtin_avail_##AVAIL \ + } + + /* Define __builtin_loongarch_<INSN>, which is a LARCH_BUILTIN_DIRECT function +@@ -137,6 +148,300 @@ AVAIL_ALL (hard_float, TARGET_HARD_FLOAT_ABI) + LARCH_BUILTIN (INSN, #INSN, LARCH_BUILTIN_DIRECT_NO_TARGET, \ + FUNCTION_TYPE, AVAIL) + ++/* Define an LSX LARCH_BUILTIN_DIRECT function __builtin_lsx_<INSN> ++ for instruction CODE_FOR_lsx_<INSN>. FUNCTION_TYPE is a builtin_description ++ field. */ ++#define LSX_BUILTIN(INSN, FUNCTION_TYPE) \ ++ { CODE_FOR_lsx_ ## INSN, \ ++ "__builtin_lsx_" #INSN, LARCH_BUILTIN_DIRECT, \ ++ FUNCTION_TYPE, loongarch_builtin_avail_lsx } ++ ++ ++/* Define an LSX LARCH_BUILTIN_LSX_TEST_BRANCH function __builtin_lsx_<INSN> ++ for instruction CODE_FOR_lsx_<INSN>. FUNCTION_TYPE is a builtin_description ++ field. */ ++#define LSX_BUILTIN_TEST_BRANCH(INSN, FUNCTION_TYPE) \ ++ { CODE_FOR_lsx_ ## INSN, \ ++ "__builtin_lsx_" #INSN, LARCH_BUILTIN_LSX_TEST_BRANCH, \ ++ FUNCTION_TYPE, loongarch_builtin_avail_lsx } ++ ++/* Define an LSX LARCH_BUILTIN_DIRECT_NO_TARGET function __builtin_lsx_<INSN> ++ for instruction CODE_FOR_lsx_<INSN>. FUNCTION_TYPE is a builtin_description ++ field. */ ++#define LSX_NO_TARGET_BUILTIN(INSN, FUNCTION_TYPE) \ ++ { CODE_FOR_lsx_ ## INSN, \ ++ "__builtin_lsx_" #INSN, LARCH_BUILTIN_DIRECT_NO_TARGET, \ ++ FUNCTION_TYPE, loongarch_builtin_avail_lsx } ++ ++/* LoongArch SX define CODE_FOR_lsx_xxx */ ++#define CODE_FOR_lsx_vsadd_b CODE_FOR_ssaddv16qi3 ++#define CODE_FOR_lsx_vsadd_h CODE_FOR_ssaddv8hi3 ++#define CODE_FOR_lsx_vsadd_w CODE_FOR_ssaddv4si3 ++#define CODE_FOR_lsx_vsadd_d CODE_FOR_ssaddv2di3 ++#define CODE_FOR_lsx_vsadd_bu CODE_FOR_usaddv16qi3 ++#define CODE_FOR_lsx_vsadd_hu CODE_FOR_usaddv8hi3 ++#define CODE_FOR_lsx_vsadd_wu CODE_FOR_usaddv4si3 ++#define CODE_FOR_lsx_vsadd_du CODE_FOR_usaddv2di3 ++#define CODE_FOR_lsx_vadd_b CODE_FOR_addv16qi3 ++#define CODE_FOR_lsx_vadd_h CODE_FOR_addv8hi3 ++#define CODE_FOR_lsx_vadd_w CODE_FOR_addv4si3 ++#define CODE_FOR_lsx_vadd_d CODE_FOR_addv2di3 ++#define CODE_FOR_lsx_vaddi_bu CODE_FOR_addv16qi3 ++#define CODE_FOR_lsx_vaddi_hu CODE_FOR_addv8hi3 ++#define CODE_FOR_lsx_vaddi_wu CODE_FOR_addv4si3 ++#define CODE_FOR_lsx_vaddi_du CODE_FOR_addv2di3 ++#define CODE_FOR_lsx_vand_v CODE_FOR_andv16qi3 ++#define CODE_FOR_lsx_vandi_b CODE_FOR_andv16qi3 ++#define CODE_FOR_lsx_bnz_v CODE_FOR_lsx_bnz_v_b ++#define CODE_FOR_lsx_bz_v CODE_FOR_lsx_bz_v_b ++#define CODE_FOR_lsx_vbitsel_v CODE_FOR_lsx_vbitsel_b ++#define CODE_FOR_lsx_vseqi_b CODE_FOR_lsx_vseq_b ++#define CODE_FOR_lsx_vseqi_h CODE_FOR_lsx_vseq_h ++#define CODE_FOR_lsx_vseqi_w CODE_FOR_lsx_vseq_w ++#define CODE_FOR_lsx_vseqi_d CODE_FOR_lsx_vseq_d ++#define CODE_FOR_lsx_vslti_b CODE_FOR_lsx_vslt_b ++#define CODE_FOR_lsx_vslti_h CODE_FOR_lsx_vslt_h ++#define CODE_FOR_lsx_vslti_w CODE_FOR_lsx_vslt_w ++#define CODE_FOR_lsx_vslti_d CODE_FOR_lsx_vslt_d ++#define CODE_FOR_lsx_vslti_bu CODE_FOR_lsx_vslt_bu ++#define CODE_FOR_lsx_vslti_hu CODE_FOR_lsx_vslt_hu ++#define CODE_FOR_lsx_vslti_wu CODE_FOR_lsx_vslt_wu ++#define CODE_FOR_lsx_vslti_du CODE_FOR_lsx_vslt_du ++#define CODE_FOR_lsx_vslei_b CODE_FOR_lsx_vsle_b ++#define CODE_FOR_lsx_vslei_h CODE_FOR_lsx_vsle_h ++#define CODE_FOR_lsx_vslei_w CODE_FOR_lsx_vsle_w ++#define CODE_FOR_lsx_vslei_d CODE_FOR_lsx_vsle_d ++#define CODE_FOR_lsx_vslei_bu CODE_FOR_lsx_vsle_bu ++#define CODE_FOR_lsx_vslei_hu CODE_FOR_lsx_vsle_hu ++#define CODE_FOR_lsx_vslei_wu CODE_FOR_lsx_vsle_wu ++#define CODE_FOR_lsx_vslei_du CODE_FOR_lsx_vsle_du ++#define CODE_FOR_lsx_vdiv_b CODE_FOR_divv16qi3 ++#define CODE_FOR_lsx_vdiv_h CODE_FOR_divv8hi3 ++#define CODE_FOR_lsx_vdiv_w CODE_FOR_divv4si3 ++#define CODE_FOR_lsx_vdiv_d CODE_FOR_divv2di3 ++#define CODE_FOR_lsx_vdiv_bu CODE_FOR_udivv16qi3 ++#define CODE_FOR_lsx_vdiv_hu CODE_FOR_udivv8hi3 ++#define CODE_FOR_lsx_vdiv_wu CODE_FOR_udivv4si3 ++#define CODE_FOR_lsx_vdiv_du CODE_FOR_udivv2di3 ++#define CODE_FOR_lsx_vfadd_s CODE_FOR_addv4sf3 ++#define CODE_FOR_lsx_vfadd_d CODE_FOR_addv2df3 ++#define CODE_FOR_lsx_vftintrz_w_s CODE_FOR_fix_truncv4sfv4si2 ++#define CODE_FOR_lsx_vftintrz_l_d CODE_FOR_fix_truncv2dfv2di2 ++#define CODE_FOR_lsx_vftintrz_wu_s CODE_FOR_fixuns_truncv4sfv4si2 ++#define CODE_FOR_lsx_vftintrz_lu_d CODE_FOR_fixuns_truncv2dfv2di2 ++#define CODE_FOR_lsx_vffint_s_w CODE_FOR_floatv4siv4sf2 ++#define CODE_FOR_lsx_vffint_d_l CODE_FOR_floatv2div2df2 ++#define CODE_FOR_lsx_vffint_s_wu CODE_FOR_floatunsv4siv4sf2 ++#define CODE_FOR_lsx_vffint_d_lu CODE_FOR_floatunsv2div2df2 ++#define CODE_FOR_lsx_vfsub_s CODE_FOR_subv4sf3 ++#define CODE_FOR_lsx_vfsub_d CODE_FOR_subv2df3 ++#define CODE_FOR_lsx_vfmul_s CODE_FOR_mulv4sf3 ++#define CODE_FOR_lsx_vfmul_d CODE_FOR_mulv2df3 ++#define CODE_FOR_lsx_vfdiv_s CODE_FOR_divv4sf3 ++#define CODE_FOR_lsx_vfdiv_d CODE_FOR_divv2df3 ++#define CODE_FOR_lsx_vfmax_s CODE_FOR_smaxv4sf3 ++#define CODE_FOR_lsx_vfmax_d CODE_FOR_smaxv2df3 ++#define CODE_FOR_lsx_vfmin_s CODE_FOR_sminv4sf3 ++#define CODE_FOR_lsx_vfmin_d CODE_FOR_sminv2df3 ++#define CODE_FOR_lsx_vfsqrt_s CODE_FOR_sqrtv4sf2 ++#define CODE_FOR_lsx_vfsqrt_d CODE_FOR_sqrtv2df2 ++#define CODE_FOR_lsx_vflogb_s CODE_FOR_logbv4sf2 ++#define CODE_FOR_lsx_vflogb_d CODE_FOR_logbv2df2 ++#define CODE_FOR_lsx_vmax_b CODE_FOR_smaxv16qi3 ++#define CODE_FOR_lsx_vmax_h CODE_FOR_smaxv8hi3 ++#define CODE_FOR_lsx_vmax_w CODE_FOR_smaxv4si3 ++#define CODE_FOR_lsx_vmax_d CODE_FOR_smaxv2di3 ++#define CODE_FOR_lsx_vmaxi_b CODE_FOR_smaxv16qi3 ++#define CODE_FOR_lsx_vmaxi_h CODE_FOR_smaxv8hi3 ++#define CODE_FOR_lsx_vmaxi_w CODE_FOR_smaxv4si3 ++#define CODE_FOR_lsx_vmaxi_d CODE_FOR_smaxv2di3 ++#define CODE_FOR_lsx_vmax_bu CODE_FOR_umaxv16qi3 ++#define CODE_FOR_lsx_vmax_hu CODE_FOR_umaxv8hi3 ++#define CODE_FOR_lsx_vmax_wu CODE_FOR_umaxv4si3 ++#define CODE_FOR_lsx_vmax_du CODE_FOR_umaxv2di3 ++#define CODE_FOR_lsx_vmaxi_bu CODE_FOR_umaxv16qi3 ++#define CODE_FOR_lsx_vmaxi_hu CODE_FOR_umaxv8hi3 ++#define CODE_FOR_lsx_vmaxi_wu CODE_FOR_umaxv4si3 ++#define CODE_FOR_lsx_vmaxi_du CODE_FOR_umaxv2di3 ++#define CODE_FOR_lsx_vmin_b CODE_FOR_sminv16qi3 ++#define CODE_FOR_lsx_vmin_h CODE_FOR_sminv8hi3 ++#define CODE_FOR_lsx_vmin_w CODE_FOR_sminv4si3 ++#define CODE_FOR_lsx_vmin_d CODE_FOR_sminv2di3 ++#define CODE_FOR_lsx_vmini_b CODE_FOR_sminv16qi3 ++#define CODE_FOR_lsx_vmini_h CODE_FOR_sminv8hi3 ++#define CODE_FOR_lsx_vmini_w CODE_FOR_sminv4si3 ++#define CODE_FOR_lsx_vmini_d CODE_FOR_sminv2di3 ++#define CODE_FOR_lsx_vmin_bu CODE_FOR_uminv16qi3 ++#define CODE_FOR_lsx_vmin_hu CODE_FOR_uminv8hi3 ++#define CODE_FOR_lsx_vmin_wu CODE_FOR_uminv4si3 ++#define CODE_FOR_lsx_vmin_du CODE_FOR_uminv2di3 ++#define CODE_FOR_lsx_vmini_bu CODE_FOR_uminv16qi3 ++#define CODE_FOR_lsx_vmini_hu CODE_FOR_uminv8hi3 ++#define CODE_FOR_lsx_vmini_wu CODE_FOR_uminv4si3 ++#define CODE_FOR_lsx_vmini_du CODE_FOR_uminv2di3 ++#define CODE_FOR_lsx_vmod_b CODE_FOR_modv16qi3 ++#define CODE_FOR_lsx_vmod_h CODE_FOR_modv8hi3 ++#define CODE_FOR_lsx_vmod_w CODE_FOR_modv4si3 ++#define CODE_FOR_lsx_vmod_d CODE_FOR_modv2di3 ++#define CODE_FOR_lsx_vmod_bu CODE_FOR_umodv16qi3 ++#define CODE_FOR_lsx_vmod_hu CODE_FOR_umodv8hi3 ++#define CODE_FOR_lsx_vmod_wu CODE_FOR_umodv4si3 ++#define CODE_FOR_lsx_vmod_du CODE_FOR_umodv2di3 ++#define CODE_FOR_lsx_vmul_b CODE_FOR_mulv16qi3 ++#define CODE_FOR_lsx_vmul_h CODE_FOR_mulv8hi3 ++#define CODE_FOR_lsx_vmul_w CODE_FOR_mulv4si3 ++#define CODE_FOR_lsx_vmul_d CODE_FOR_mulv2di3 ++#define CODE_FOR_lsx_vclz_b CODE_FOR_clzv16qi2 ++#define CODE_FOR_lsx_vclz_h CODE_FOR_clzv8hi2 ++#define CODE_FOR_lsx_vclz_w CODE_FOR_clzv4si2 ++#define CODE_FOR_lsx_vclz_d CODE_FOR_clzv2di2 ++#define CODE_FOR_lsx_vnor_v CODE_FOR_lsx_nor_b ++#define CODE_FOR_lsx_vor_v CODE_FOR_iorv16qi3 ++#define CODE_FOR_lsx_vori_b CODE_FOR_iorv16qi3 ++#define CODE_FOR_lsx_vnori_b CODE_FOR_lsx_nor_b ++#define CODE_FOR_lsx_vpcnt_b CODE_FOR_popcountv16qi2 ++#define CODE_FOR_lsx_vpcnt_h CODE_FOR_popcountv8hi2 ++#define CODE_FOR_lsx_vpcnt_w CODE_FOR_popcountv4si2 ++#define CODE_FOR_lsx_vpcnt_d CODE_FOR_popcountv2di2 ++#define CODE_FOR_lsx_vxor_v CODE_FOR_xorv16qi3 ++#define CODE_FOR_lsx_vxori_b CODE_FOR_xorv16qi3 ++#define CODE_FOR_lsx_vsll_b CODE_FOR_vashlv16qi3 ++#define CODE_FOR_lsx_vsll_h CODE_FOR_vashlv8hi3 ++#define CODE_FOR_lsx_vsll_w CODE_FOR_vashlv4si3 ++#define CODE_FOR_lsx_vsll_d CODE_FOR_vashlv2di3 ++#define CODE_FOR_lsx_vslli_b CODE_FOR_vashlv16qi3 ++#define CODE_FOR_lsx_vslli_h CODE_FOR_vashlv8hi3 ++#define CODE_FOR_lsx_vslli_w CODE_FOR_vashlv4si3 ++#define CODE_FOR_lsx_vslli_d CODE_FOR_vashlv2di3 ++#define CODE_FOR_lsx_vsra_b CODE_FOR_vashrv16qi3 ++#define CODE_FOR_lsx_vsra_h CODE_FOR_vashrv8hi3 ++#define CODE_FOR_lsx_vsra_w CODE_FOR_vashrv4si3 ++#define CODE_FOR_lsx_vsra_d CODE_FOR_vashrv2di3 ++#define CODE_FOR_lsx_vsrai_b CODE_FOR_vashrv16qi3 ++#define CODE_FOR_lsx_vsrai_h CODE_FOR_vashrv8hi3 ++#define CODE_FOR_lsx_vsrai_w CODE_FOR_vashrv4si3 ++#define CODE_FOR_lsx_vsrai_d CODE_FOR_vashrv2di3 ++#define CODE_FOR_lsx_vsrl_b CODE_FOR_vlshrv16qi3 ++#define CODE_FOR_lsx_vsrl_h CODE_FOR_vlshrv8hi3 ++#define CODE_FOR_lsx_vsrl_w CODE_FOR_vlshrv4si3 ++#define CODE_FOR_lsx_vsrl_d CODE_FOR_vlshrv2di3 ++#define CODE_FOR_lsx_vsrli_b CODE_FOR_vlshrv16qi3 ++#define CODE_FOR_lsx_vsrli_h CODE_FOR_vlshrv8hi3 ++#define CODE_FOR_lsx_vsrli_w CODE_FOR_vlshrv4si3 ++#define CODE_FOR_lsx_vsrli_d CODE_FOR_vlshrv2di3 ++#define CODE_FOR_lsx_vsub_b CODE_FOR_subv16qi3 ++#define CODE_FOR_lsx_vsub_h CODE_FOR_subv8hi3 ++#define CODE_FOR_lsx_vsub_w CODE_FOR_subv4si3 ++#define CODE_FOR_lsx_vsub_d CODE_FOR_subv2di3 ++#define CODE_FOR_lsx_vsubi_bu CODE_FOR_subv16qi3 ++#define CODE_FOR_lsx_vsubi_hu CODE_FOR_subv8hi3 ++#define CODE_FOR_lsx_vsubi_wu CODE_FOR_subv4si3 ++#define CODE_FOR_lsx_vsubi_du CODE_FOR_subv2di3 ++ ++#define CODE_FOR_lsx_vpackod_d CODE_FOR_lsx_vilvh_d ++#define CODE_FOR_lsx_vpackev_d CODE_FOR_lsx_vilvl_d ++#define CODE_FOR_lsx_vpickod_d CODE_FOR_lsx_vilvh_d ++#define CODE_FOR_lsx_vpickev_d CODE_FOR_lsx_vilvl_d ++ ++#define CODE_FOR_lsx_vrepli_b CODE_FOR_lsx_vrepliv16qi ++#define CODE_FOR_lsx_vrepli_h CODE_FOR_lsx_vrepliv8hi ++#define CODE_FOR_lsx_vrepli_w CODE_FOR_lsx_vrepliv4si ++#define CODE_FOR_lsx_vrepli_d CODE_FOR_lsx_vrepliv2di ++#define CODE_FOR_lsx_vsat_b CODE_FOR_lsx_vsat_s_b ++#define CODE_FOR_lsx_vsat_h CODE_FOR_lsx_vsat_s_h ++#define CODE_FOR_lsx_vsat_w CODE_FOR_lsx_vsat_s_w ++#define CODE_FOR_lsx_vsat_d CODE_FOR_lsx_vsat_s_d ++#define CODE_FOR_lsx_vsat_bu CODE_FOR_lsx_vsat_u_bu ++#define CODE_FOR_lsx_vsat_hu CODE_FOR_lsx_vsat_u_hu ++#define CODE_FOR_lsx_vsat_wu CODE_FOR_lsx_vsat_u_wu ++#define CODE_FOR_lsx_vsat_du CODE_FOR_lsx_vsat_u_du ++#define CODE_FOR_lsx_vavg_b CODE_FOR_lsx_vavg_s_b ++#define CODE_FOR_lsx_vavg_h CODE_FOR_lsx_vavg_s_h ++#define CODE_FOR_lsx_vavg_w CODE_FOR_lsx_vavg_s_w ++#define CODE_FOR_lsx_vavg_d CODE_FOR_lsx_vavg_s_d ++#define CODE_FOR_lsx_vavg_bu CODE_FOR_lsx_vavg_u_bu ++#define CODE_FOR_lsx_vavg_hu CODE_FOR_lsx_vavg_u_hu ++#define CODE_FOR_lsx_vavg_wu CODE_FOR_lsx_vavg_u_wu ++#define CODE_FOR_lsx_vavg_du CODE_FOR_lsx_vavg_u_du ++#define CODE_FOR_lsx_vavgr_b CODE_FOR_lsx_vavgr_s_b ++#define CODE_FOR_lsx_vavgr_h CODE_FOR_lsx_vavgr_s_h ++#define CODE_FOR_lsx_vavgr_w CODE_FOR_lsx_vavgr_s_w ++#define CODE_FOR_lsx_vavgr_d CODE_FOR_lsx_vavgr_s_d ++#define CODE_FOR_lsx_vavgr_bu CODE_FOR_lsx_vavgr_u_bu ++#define CODE_FOR_lsx_vavgr_hu CODE_FOR_lsx_vavgr_u_hu ++#define CODE_FOR_lsx_vavgr_wu CODE_FOR_lsx_vavgr_u_wu ++#define CODE_FOR_lsx_vavgr_du CODE_FOR_lsx_vavgr_u_du ++#define CODE_FOR_lsx_vssub_b CODE_FOR_lsx_vssub_s_b ++#define CODE_FOR_lsx_vssub_h CODE_FOR_lsx_vssub_s_h ++#define CODE_FOR_lsx_vssub_w CODE_FOR_lsx_vssub_s_w ++#define CODE_FOR_lsx_vssub_d CODE_FOR_lsx_vssub_s_d ++#define CODE_FOR_lsx_vssub_bu CODE_FOR_lsx_vssub_u_bu ++#define CODE_FOR_lsx_vssub_hu CODE_FOR_lsx_vssub_u_hu ++#define CODE_FOR_lsx_vssub_wu CODE_FOR_lsx_vssub_u_wu ++#define CODE_FOR_lsx_vssub_du CODE_FOR_lsx_vssub_u_du ++#define CODE_FOR_lsx_vabsd_b CODE_FOR_lsx_vabsd_s_b ++#define CODE_FOR_lsx_vabsd_h CODE_FOR_lsx_vabsd_s_h ++#define CODE_FOR_lsx_vabsd_w CODE_FOR_lsx_vabsd_s_w ++#define CODE_FOR_lsx_vabsd_d CODE_FOR_lsx_vabsd_s_d ++#define CODE_FOR_lsx_vabsd_bu CODE_FOR_lsx_vabsd_u_bu ++#define CODE_FOR_lsx_vabsd_hu CODE_FOR_lsx_vabsd_u_hu ++#define CODE_FOR_lsx_vabsd_wu CODE_FOR_lsx_vabsd_u_wu ++#define CODE_FOR_lsx_vabsd_du CODE_FOR_lsx_vabsd_u_du ++#define CODE_FOR_lsx_vftint_w_s CODE_FOR_lsx_vftint_s_w_s ++#define CODE_FOR_lsx_vftint_l_d CODE_FOR_lsx_vftint_s_l_d ++#define CODE_FOR_lsx_vftint_wu_s CODE_FOR_lsx_vftint_u_wu_s ++#define CODE_FOR_lsx_vftint_lu_d CODE_FOR_lsx_vftint_u_lu_d ++#define CODE_FOR_lsx_vandn_v CODE_FOR_vandnv16qi3 ++#define CODE_FOR_lsx_vorn_v CODE_FOR_vornv16qi3 ++#define CODE_FOR_lsx_vneg_b CODE_FOR_vnegv16qi2 ++#define CODE_FOR_lsx_vneg_h CODE_FOR_vnegv8hi2 ++#define CODE_FOR_lsx_vneg_w CODE_FOR_vnegv4si2 ++#define CODE_FOR_lsx_vneg_d CODE_FOR_vnegv2di2 ++#define CODE_FOR_lsx_vshuf4i_d CODE_FOR_lsx_vshuf4i_d ++#define CODE_FOR_lsx_vbsrl_v CODE_FOR_lsx_vbsrl_b ++#define CODE_FOR_lsx_vbsll_v CODE_FOR_lsx_vbsll_b ++#define CODE_FOR_lsx_vfmadd_s CODE_FOR_fmav4sf4 ++#define CODE_FOR_lsx_vfmadd_d CODE_FOR_fmav2df4 ++#define CODE_FOR_lsx_vfmsub_s CODE_FOR_fmsv4sf4 ++#define CODE_FOR_lsx_vfmsub_d CODE_FOR_fmsv2df4 ++#define CODE_FOR_lsx_vfnmadd_s CODE_FOR_vfnmaddv4sf4_nmadd4 ++#define CODE_FOR_lsx_vfnmadd_d CODE_FOR_vfnmaddv2df4_nmadd4 ++#define CODE_FOR_lsx_vfnmsub_s CODE_FOR_vfnmsubv4sf4_nmsub4 ++#define CODE_FOR_lsx_vfnmsub_d CODE_FOR_vfnmsubv2df4_nmsub4 ++ ++#define CODE_FOR_lsx_vmuh_b CODE_FOR_lsx_vmuh_s_b ++#define CODE_FOR_lsx_vmuh_h CODE_FOR_lsx_vmuh_s_h ++#define CODE_FOR_lsx_vmuh_w CODE_FOR_lsx_vmuh_s_w ++#define CODE_FOR_lsx_vmuh_d CODE_FOR_lsx_vmuh_s_d ++#define CODE_FOR_lsx_vmuh_bu CODE_FOR_lsx_vmuh_u_bu ++#define CODE_FOR_lsx_vmuh_hu CODE_FOR_lsx_vmuh_u_hu ++#define CODE_FOR_lsx_vmuh_wu CODE_FOR_lsx_vmuh_u_wu ++#define CODE_FOR_lsx_vmuh_du CODE_FOR_lsx_vmuh_u_du ++#define CODE_FOR_lsx_vsllwil_h_b CODE_FOR_lsx_vsllwil_s_h_b ++#define CODE_FOR_lsx_vsllwil_w_h CODE_FOR_lsx_vsllwil_s_w_h ++#define CODE_FOR_lsx_vsllwil_d_w CODE_FOR_lsx_vsllwil_s_d_w ++#define CODE_FOR_lsx_vsllwil_hu_bu CODE_FOR_lsx_vsllwil_u_hu_bu ++#define CODE_FOR_lsx_vsllwil_wu_hu CODE_FOR_lsx_vsllwil_u_wu_hu ++#define CODE_FOR_lsx_vsllwil_du_wu CODE_FOR_lsx_vsllwil_u_du_wu ++#define CODE_FOR_lsx_vssran_b_h CODE_FOR_lsx_vssran_s_b_h ++#define CODE_FOR_lsx_vssran_h_w CODE_FOR_lsx_vssran_s_h_w ++#define CODE_FOR_lsx_vssran_w_d CODE_FOR_lsx_vssran_s_w_d ++#define CODE_FOR_lsx_vssran_bu_h CODE_FOR_lsx_vssran_u_bu_h ++#define CODE_FOR_lsx_vssran_hu_w CODE_FOR_lsx_vssran_u_hu_w ++#define CODE_FOR_lsx_vssran_wu_d CODE_FOR_lsx_vssran_u_wu_d ++#define CODE_FOR_lsx_vssrarn_b_h CODE_FOR_lsx_vssrarn_s_b_h ++#define CODE_FOR_lsx_vssrarn_h_w CODE_FOR_lsx_vssrarn_s_h_w ++#define CODE_FOR_lsx_vssrarn_w_d CODE_FOR_lsx_vssrarn_s_w_d ++#define CODE_FOR_lsx_vssrarn_bu_h CODE_FOR_lsx_vssrarn_u_bu_h ++#define CODE_FOR_lsx_vssrarn_hu_w CODE_FOR_lsx_vssrarn_u_hu_w ++#define CODE_FOR_lsx_vssrarn_wu_d CODE_FOR_lsx_vssrarn_u_wu_d ++#define CODE_FOR_lsx_vssrln_bu_h CODE_FOR_lsx_vssrln_u_bu_h ++#define CODE_FOR_lsx_vssrln_hu_w CODE_FOR_lsx_vssrln_u_hu_w ++#define CODE_FOR_lsx_vssrln_wu_d CODE_FOR_lsx_vssrln_u_wu_d ++#define CODE_FOR_lsx_vssrlrn_bu_h CODE_FOR_lsx_vssrlrn_u_bu_h ++#define CODE_FOR_lsx_vssrlrn_hu_w CODE_FOR_lsx_vssrlrn_u_hu_w ++#define CODE_FOR_lsx_vssrlrn_wu_d CODE_FOR_lsx_vssrlrn_u_wu_d ++ + static const struct loongarch_builtin_description loongarch_builtins = { + #define LARCH_MOVFCSR2GR 0 + DIRECT_BUILTIN (movfcsr2gr, LARCH_USI_FTYPE_UQI, hard_float), +@@ -184,6 +489,727 @@ static const struct loongarch_builtin_description loongarch_builtins = { + DIRECT_NO_TARGET_BUILTIN (asrtgt_d, LARCH_VOID_FTYPE_DI_DI, default), + DIRECT_NO_TARGET_BUILTIN (syscall, LARCH_VOID_FTYPE_USI, default), + DIRECT_NO_TARGET_BUILTIN (break, LARCH_VOID_FTYPE_USI, default), ++ ++ /* Built-in functions for LSX. */ ++ LSX_BUILTIN (vsll_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsll_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsll_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsll_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vslli_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vslli_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vslli_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vslli_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vsra_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsra_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsra_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsra_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsrai_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vsrai_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vsrai_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vsrai_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vsrar_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsrar_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsrar_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsrar_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsrari_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vsrari_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vsrari_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vsrari_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vsrl_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsrl_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsrl_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsrl_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsrli_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vsrli_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vsrli_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vsrli_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vsrlr_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsrlr_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsrlr_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsrlr_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsrlri_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vsrlri_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vsrlri_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vsrlri_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vbitclr_b, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vbitclr_h, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vbitclr_w, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vbitclr_d, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vbitclri_b, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vbitclri_h, LARCH_UV8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vbitclri_w, LARCH_UV4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vbitclri_d, LARCH_UV2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vbitset_b, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vbitset_h, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vbitset_w, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vbitset_d, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vbitseti_b, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vbitseti_h, LARCH_UV8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vbitseti_w, LARCH_UV4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vbitseti_d, LARCH_UV2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vbitrev_b, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vbitrev_h, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vbitrev_w, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vbitrev_d, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vbitrevi_b, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vbitrevi_h, LARCH_UV8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vbitrevi_w, LARCH_UV4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vbitrevi_d, LARCH_UV2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vadd_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vadd_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vadd_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vadd_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vaddi_bu, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vaddi_hu, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vaddi_wu, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vaddi_du, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vsub_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsub_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsub_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsub_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsubi_bu, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vsubi_hu, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vsubi_wu, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vsubi_du, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vmax_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vmax_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vmax_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vmax_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vmaxi_b, LARCH_V16QI_FTYPE_V16QI_QI), ++ LSX_BUILTIN (vmaxi_h, LARCH_V8HI_FTYPE_V8HI_QI), ++ LSX_BUILTIN (vmaxi_w, LARCH_V4SI_FTYPE_V4SI_QI), ++ LSX_BUILTIN (vmaxi_d, LARCH_V2DI_FTYPE_V2DI_QI), ++ LSX_BUILTIN (vmax_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vmax_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vmax_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vmax_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vmaxi_bu, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vmaxi_hu, LARCH_UV8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vmaxi_wu, LARCH_UV4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vmaxi_du, LARCH_UV2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vmin_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vmin_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vmin_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vmin_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vmini_b, LARCH_V16QI_FTYPE_V16QI_QI), ++ LSX_BUILTIN (vmini_h, LARCH_V8HI_FTYPE_V8HI_QI), ++ LSX_BUILTIN (vmini_w, LARCH_V4SI_FTYPE_V4SI_QI), ++ LSX_BUILTIN (vmini_d, LARCH_V2DI_FTYPE_V2DI_QI), ++ LSX_BUILTIN (vmin_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vmin_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vmin_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vmin_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vmini_bu, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vmini_hu, LARCH_UV8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vmini_wu, LARCH_UV4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vmini_du, LARCH_UV2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vseq_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vseq_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vseq_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vseq_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vseqi_b, LARCH_V16QI_FTYPE_V16QI_QI), ++ LSX_BUILTIN (vseqi_h, LARCH_V8HI_FTYPE_V8HI_QI), ++ LSX_BUILTIN (vseqi_w, LARCH_V4SI_FTYPE_V4SI_QI), ++ LSX_BUILTIN (vseqi_d, LARCH_V2DI_FTYPE_V2DI_QI), ++ LSX_BUILTIN (vslti_b, LARCH_V16QI_FTYPE_V16QI_QI), ++ LSX_BUILTIN (vslt_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vslt_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vslt_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vslt_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vslti_h, LARCH_V8HI_FTYPE_V8HI_QI), ++ LSX_BUILTIN (vslti_w, LARCH_V4SI_FTYPE_V4SI_QI), ++ LSX_BUILTIN (vslti_d, LARCH_V2DI_FTYPE_V2DI_QI), ++ LSX_BUILTIN (vslt_bu, LARCH_V16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vslt_hu, LARCH_V8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vslt_wu, LARCH_V4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vslt_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vslti_bu, LARCH_V16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vslti_hu, LARCH_V8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vslti_wu, LARCH_V4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vslti_du, LARCH_V2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vsle_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsle_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsle_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsle_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vslei_b, LARCH_V16QI_FTYPE_V16QI_QI), ++ LSX_BUILTIN (vslei_h, LARCH_V8HI_FTYPE_V8HI_QI), ++ LSX_BUILTIN (vslei_w, LARCH_V4SI_FTYPE_V4SI_QI), ++ LSX_BUILTIN (vslei_d, LARCH_V2DI_FTYPE_V2DI_QI), ++ LSX_BUILTIN (vsle_bu, LARCH_V16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vsle_hu, LARCH_V8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vsle_wu, LARCH_V4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vsle_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vslei_bu, LARCH_V16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vslei_hu, LARCH_V8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vslei_wu, LARCH_V4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vslei_du, LARCH_V2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vsat_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vsat_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vsat_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vsat_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vsat_bu, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vsat_hu, LARCH_UV8HI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vsat_wu, LARCH_UV4SI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vsat_du, LARCH_UV2DI_FTYPE_UV2DI_UQI), ++ LSX_BUILTIN (vadda_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vadda_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vadda_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vadda_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsadd_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsadd_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsadd_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsadd_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsadd_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vsadd_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vsadd_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vsadd_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vavg_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vavg_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vavg_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vavg_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vavg_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vavg_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vavg_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vavg_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vavgr_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vavgr_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vavgr_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vavgr_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vavgr_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vavgr_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vavgr_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vavgr_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vssub_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vssub_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vssub_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vssub_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssub_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vssub_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vssub_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vssub_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vabsd_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vabsd_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vabsd_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vabsd_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vabsd_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vabsd_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vabsd_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vabsd_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vmul_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vmul_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vmul_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vmul_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vmadd_b, LARCH_V16QI_FTYPE_V16QI_V16QI_V16QI), ++ LSX_BUILTIN (vmadd_h, LARCH_V8HI_FTYPE_V8HI_V8HI_V8HI), ++ LSX_BUILTIN (vmadd_w, LARCH_V4SI_FTYPE_V4SI_V4SI_V4SI), ++ LSX_BUILTIN (vmadd_d, LARCH_V2DI_FTYPE_V2DI_V2DI_V2DI), ++ LSX_BUILTIN (vmsub_b, LARCH_V16QI_FTYPE_V16QI_V16QI_V16QI), ++ LSX_BUILTIN (vmsub_h, LARCH_V8HI_FTYPE_V8HI_V8HI_V8HI), ++ LSX_BUILTIN (vmsub_w, LARCH_V4SI_FTYPE_V4SI_V4SI_V4SI), ++ LSX_BUILTIN (vmsub_d, LARCH_V2DI_FTYPE_V2DI_V2DI_V2DI), ++ LSX_BUILTIN (vdiv_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vdiv_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vdiv_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vdiv_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vdiv_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vdiv_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vdiv_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vdiv_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vhaddw_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vhaddw_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vhaddw_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vhaddw_hu_bu, LARCH_UV8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vhaddw_wu_hu, LARCH_UV4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vhaddw_du_wu, LARCH_UV2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vhsubw_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vhsubw_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vhsubw_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vhsubw_hu_bu, LARCH_V8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vhsubw_wu_hu, LARCH_V4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vhsubw_du_wu, LARCH_V2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vmod_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vmod_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vmod_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vmod_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vmod_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vmod_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vmod_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vmod_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vreplve_b, LARCH_V16QI_FTYPE_V16QI_SI), ++ LSX_BUILTIN (vreplve_h, LARCH_V8HI_FTYPE_V8HI_SI), ++ LSX_BUILTIN (vreplve_w, LARCH_V4SI_FTYPE_V4SI_SI), ++ LSX_BUILTIN (vreplve_d, LARCH_V2DI_FTYPE_V2DI_SI), ++ LSX_BUILTIN (vreplvei_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vreplvei_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vreplvei_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vreplvei_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vpickev_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vpickev_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vpickev_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vpickev_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vpickod_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vpickod_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vpickod_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vpickod_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vilvh_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vilvh_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vilvh_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vilvh_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vilvl_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vilvl_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vilvl_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vilvl_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vpackev_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vpackev_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vpackev_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vpackev_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vpackod_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vpackod_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vpackod_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vpackod_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vshuf_h, LARCH_V8HI_FTYPE_V8HI_V8HI_V8HI), ++ LSX_BUILTIN (vshuf_w, LARCH_V4SI_FTYPE_V4SI_V4SI_V4SI), ++ LSX_BUILTIN (vshuf_d, LARCH_V2DI_FTYPE_V2DI_V2DI_V2DI), ++ LSX_BUILTIN (vand_v, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vandi_b, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vor_v, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vori_b, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vnor_v, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vnori_b, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vxor_v, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vxori_b, LARCH_UV16QI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vbitsel_v, LARCH_UV16QI_FTYPE_UV16QI_UV16QI_UV16QI), ++ LSX_BUILTIN (vbitseli_b, LARCH_UV16QI_FTYPE_UV16QI_UV16QI_USI), ++ LSX_BUILTIN (vshuf4i_b, LARCH_V16QI_FTYPE_V16QI_USI), ++ LSX_BUILTIN (vshuf4i_h, LARCH_V8HI_FTYPE_V8HI_USI), ++ LSX_BUILTIN (vshuf4i_w, LARCH_V4SI_FTYPE_V4SI_USI), ++ LSX_BUILTIN (vreplgr2vr_b, LARCH_V16QI_FTYPE_SI), ++ LSX_BUILTIN (vreplgr2vr_h, LARCH_V8HI_FTYPE_SI), ++ LSX_BUILTIN (vreplgr2vr_w, LARCH_V4SI_FTYPE_SI), ++ LSX_BUILTIN (vreplgr2vr_d, LARCH_V2DI_FTYPE_DI), ++ LSX_BUILTIN (vpcnt_b, LARCH_V16QI_FTYPE_V16QI), ++ LSX_BUILTIN (vpcnt_h, LARCH_V8HI_FTYPE_V8HI), ++ LSX_BUILTIN (vpcnt_w, LARCH_V4SI_FTYPE_V4SI), ++ LSX_BUILTIN (vpcnt_d, LARCH_V2DI_FTYPE_V2DI), ++ LSX_BUILTIN (vclo_b, LARCH_V16QI_FTYPE_V16QI), ++ LSX_BUILTIN (vclo_h, LARCH_V8HI_FTYPE_V8HI), ++ LSX_BUILTIN (vclo_w, LARCH_V4SI_FTYPE_V4SI), ++ LSX_BUILTIN (vclo_d, LARCH_V2DI_FTYPE_V2DI), ++ LSX_BUILTIN (vclz_b, LARCH_V16QI_FTYPE_V16QI), ++ LSX_BUILTIN (vclz_h, LARCH_V8HI_FTYPE_V8HI), ++ LSX_BUILTIN (vclz_w, LARCH_V4SI_FTYPE_V4SI), ++ LSX_BUILTIN (vclz_d, LARCH_V2DI_FTYPE_V2DI), ++ LSX_BUILTIN (vpickve2gr_b, LARCH_SI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vpickve2gr_h, LARCH_SI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vpickve2gr_w, LARCH_SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vpickve2gr_d, LARCH_DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vpickve2gr_bu, LARCH_USI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vpickve2gr_hu, LARCH_USI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vpickve2gr_wu, LARCH_USI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vpickve2gr_du, LARCH_UDI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vinsgr2vr_b, LARCH_V16QI_FTYPE_V16QI_SI_UQI), ++ LSX_BUILTIN (vinsgr2vr_h, LARCH_V8HI_FTYPE_V8HI_SI_UQI), ++ LSX_BUILTIN (vinsgr2vr_w, LARCH_V4SI_FTYPE_V4SI_SI_UQI), ++ LSX_BUILTIN (vinsgr2vr_d, LARCH_V2DI_FTYPE_V2DI_DI_UQI), ++ LSX_BUILTIN_TEST_BRANCH (bnz_b, LARCH_SI_FTYPE_UV16QI), ++ LSX_BUILTIN_TEST_BRANCH (bnz_h, LARCH_SI_FTYPE_UV8HI), ++ LSX_BUILTIN_TEST_BRANCH (bnz_w, LARCH_SI_FTYPE_UV4SI), ++ LSX_BUILTIN_TEST_BRANCH (bnz_d, LARCH_SI_FTYPE_UV2DI), ++ LSX_BUILTIN_TEST_BRANCH (bz_b, LARCH_SI_FTYPE_UV16QI), ++ LSX_BUILTIN_TEST_BRANCH (bz_h, LARCH_SI_FTYPE_UV8HI), ++ LSX_BUILTIN_TEST_BRANCH (bz_w, LARCH_SI_FTYPE_UV4SI), ++ LSX_BUILTIN_TEST_BRANCH (bz_d, LARCH_SI_FTYPE_UV2DI), ++ LSX_BUILTIN_TEST_BRANCH (bz_v, LARCH_SI_FTYPE_UV16QI), ++ LSX_BUILTIN_TEST_BRANCH (bnz_v, LARCH_SI_FTYPE_UV16QI), ++ LSX_BUILTIN (vrepli_b, LARCH_V16QI_FTYPE_HI), ++ LSX_BUILTIN (vrepli_h, LARCH_V8HI_FTYPE_HI), ++ LSX_BUILTIN (vrepli_w, LARCH_V4SI_FTYPE_HI), ++ LSX_BUILTIN (vrepli_d, LARCH_V2DI_FTYPE_HI), ++ LSX_BUILTIN (vfcmp_caf_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_caf_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cor_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cor_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cun_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cun_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cune_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cune_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cueq_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cueq_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_ceq_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_ceq_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cne_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cne_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_clt_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_clt_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cult_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cult_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cle_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cle_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_cule_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_cule_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_saf_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_saf_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sor_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sor_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sun_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sun_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sune_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sune_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sueq_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sueq_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_seq_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_seq_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sne_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sne_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_slt_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_slt_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sult_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sult_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sle_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sle_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcmp_sule_s, LARCH_V4SI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcmp_sule_d, LARCH_V2DI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfadd_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfadd_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfsub_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfsub_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfmul_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfmul_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfdiv_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfdiv_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfcvt_h_s, LARCH_V8HI_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfcvt_s_d, LARCH_V4SF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfmin_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfmin_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfmina_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfmina_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfmax_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfmax_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfmaxa_s, LARCH_V4SF_FTYPE_V4SF_V4SF), ++ LSX_BUILTIN (vfmaxa_d, LARCH_V2DF_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vfclass_s, LARCH_V4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vfclass_d, LARCH_V2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vfsqrt_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfsqrt_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vfrecip_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfrecip_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vfrint_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfrint_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vfrsqrt_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfrsqrt_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vflogb_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vflogb_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vfcvth_s_h, LARCH_V4SF_FTYPE_V8HI), ++ LSX_BUILTIN (vfcvth_d_s, LARCH_V2DF_FTYPE_V4SF), ++ LSX_BUILTIN (vfcvtl_s_h, LARCH_V4SF_FTYPE_V8HI), ++ LSX_BUILTIN (vfcvtl_d_s, LARCH_V2DF_FTYPE_V4SF), ++ LSX_BUILTIN (vftint_w_s, LARCH_V4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vftint_l_d, LARCH_V2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vftint_wu_s, LARCH_UV4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vftint_lu_d, LARCH_UV2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vftintrz_w_s, LARCH_V4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrz_l_d, LARCH_V2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vftintrz_wu_s, LARCH_UV4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrz_lu_d, LARCH_UV2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vffint_s_w, LARCH_V4SF_FTYPE_V4SI), ++ LSX_BUILTIN (vffint_d_l, LARCH_V2DF_FTYPE_V2DI), ++ LSX_BUILTIN (vffint_s_wu, LARCH_V4SF_FTYPE_UV4SI), ++ LSX_BUILTIN (vffint_d_lu, LARCH_V2DF_FTYPE_UV2DI), ++ ++ LSX_BUILTIN (vandn_v, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vneg_b, LARCH_V16QI_FTYPE_V16QI), ++ LSX_BUILTIN (vneg_h, LARCH_V8HI_FTYPE_V8HI), ++ LSX_BUILTIN (vneg_w, LARCH_V4SI_FTYPE_V4SI), ++ LSX_BUILTIN (vneg_d, LARCH_V2DI_FTYPE_V2DI), ++ LSX_BUILTIN (vmuh_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vmuh_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vmuh_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vmuh_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vmuh_bu, LARCH_UV16QI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vmuh_hu, LARCH_UV8HI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vmuh_wu, LARCH_UV4SI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vmuh_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vsllwil_h_b, LARCH_V8HI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vsllwil_w_h, LARCH_V4SI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vsllwil_d_w, LARCH_V2DI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vsllwil_hu_bu, LARCH_UV8HI_FTYPE_UV16QI_UQI), ++ LSX_BUILTIN (vsllwil_wu_hu, LARCH_UV4SI_FTYPE_UV8HI_UQI), ++ LSX_BUILTIN (vsllwil_du_wu, LARCH_UV2DI_FTYPE_UV4SI_UQI), ++ LSX_BUILTIN (vsran_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsran_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsran_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssran_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vssran_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vssran_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssran_bu_h, LARCH_UV16QI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vssran_hu_w, LARCH_UV8HI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vssran_wu_d, LARCH_UV4SI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vsrarn_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsrarn_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsrarn_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssrarn_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vssrarn_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vssrarn_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssrarn_bu_h, LARCH_UV16QI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vssrarn_hu_w, LARCH_UV8HI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vssrarn_wu_d, LARCH_UV4SI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vsrln_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsrln_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsrln_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssrln_bu_h, LARCH_UV16QI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vssrln_hu_w, LARCH_UV8HI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vssrln_wu_d, LARCH_UV4SI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vsrlrn_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsrlrn_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsrlrn_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssrlrn_bu_h, LARCH_UV16QI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vssrlrn_hu_w, LARCH_UV8HI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vssrlrn_wu_d, LARCH_UV4SI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vfrstpi_b, LARCH_V16QI_FTYPE_V16QI_V16QI_UQI), ++ LSX_BUILTIN (vfrstpi_h, LARCH_V8HI_FTYPE_V8HI_V8HI_UQI), ++ LSX_BUILTIN (vfrstp_b, LARCH_V16QI_FTYPE_V16QI_V16QI_V16QI), ++ LSX_BUILTIN (vfrstp_h, LARCH_V8HI_FTYPE_V8HI_V8HI_V8HI), ++ LSX_BUILTIN (vshuf4i_d, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vbsrl_v, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vbsll_v, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vextrins_b, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vextrins_h, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vextrins_w, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vextrins_d, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vmskltz_b, LARCH_V16QI_FTYPE_V16QI), ++ LSX_BUILTIN (vmskltz_h, LARCH_V8HI_FTYPE_V8HI), ++ LSX_BUILTIN (vmskltz_w, LARCH_V4SI_FTYPE_V4SI), ++ LSX_BUILTIN (vmskltz_d, LARCH_V2DI_FTYPE_V2DI), ++ LSX_BUILTIN (vsigncov_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsigncov_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsigncov_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsigncov_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vfmadd_s, LARCH_V4SF_FTYPE_V4SF_V4SF_V4SF), ++ LSX_BUILTIN (vfmadd_d, LARCH_V2DF_FTYPE_V2DF_V2DF_V2DF), ++ LSX_BUILTIN (vfmsub_s, LARCH_V4SF_FTYPE_V4SF_V4SF_V4SF), ++ LSX_BUILTIN (vfmsub_d, LARCH_V2DF_FTYPE_V2DF_V2DF_V2DF), ++ LSX_BUILTIN (vfnmadd_s, LARCH_V4SF_FTYPE_V4SF_V4SF_V4SF), ++ LSX_BUILTIN (vfnmadd_d, LARCH_V2DF_FTYPE_V2DF_V2DF_V2DF), ++ LSX_BUILTIN (vfnmsub_s, LARCH_V4SF_FTYPE_V4SF_V4SF_V4SF), ++ LSX_BUILTIN (vfnmsub_d, LARCH_V2DF_FTYPE_V2DF_V2DF_V2DF), ++ LSX_BUILTIN (vftintrne_w_s, LARCH_V4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrne_l_d, LARCH_V2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vftintrp_w_s, LARCH_V4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrp_l_d, LARCH_V2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vftintrm_w_s, LARCH_V4SI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrm_l_d, LARCH_V2DI_FTYPE_V2DF), ++ LSX_BUILTIN (vftint_w_d, LARCH_V4SI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vffint_s_l, LARCH_V4SF_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vftintrz_w_d, LARCH_V4SI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vftintrp_w_d, LARCH_V4SI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vftintrm_w_d, LARCH_V4SI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vftintrne_w_d, LARCH_V4SI_FTYPE_V2DF_V2DF), ++ LSX_BUILTIN (vftintl_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftinth_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vffinth_d_w, LARCH_V2DF_FTYPE_V4SI), ++ LSX_BUILTIN (vffintl_d_w, LARCH_V2DF_FTYPE_V4SI), ++ LSX_BUILTIN (vftintrzl_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrzh_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrpl_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrph_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrml_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrmh_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrnel_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vftintrneh_l_s, LARCH_V2DI_FTYPE_V4SF), ++ LSX_BUILTIN (vfrintrne_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfrintrne_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vfrintrz_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfrintrz_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vfrintrp_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfrintrp_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_BUILTIN (vfrintrm_s, LARCH_V4SF_FTYPE_V4SF), ++ LSX_BUILTIN (vfrintrm_d, LARCH_V2DF_FTYPE_V2DF), ++ LSX_NO_TARGET_BUILTIN (vstelm_b, LARCH_VOID_FTYPE_V16QI_CVPOINTER_SI_UQI), ++ LSX_NO_TARGET_BUILTIN (vstelm_h, LARCH_VOID_FTYPE_V8HI_CVPOINTER_SI_UQI), ++ LSX_NO_TARGET_BUILTIN (vstelm_w, LARCH_VOID_FTYPE_V4SI_CVPOINTER_SI_UQI), ++ LSX_NO_TARGET_BUILTIN (vstelm_d, LARCH_VOID_FTYPE_V2DI_CVPOINTER_SI_UQI), ++ LSX_BUILTIN (vaddwev_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vaddwev_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vaddwev_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vaddwod_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vaddwod_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vaddwod_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vaddwev_d_wu, LARCH_V2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vaddwev_w_hu, LARCH_V4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vaddwev_h_bu, LARCH_V8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vaddwod_d_wu, LARCH_V2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vaddwod_w_hu, LARCH_V4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vaddwod_h_bu, LARCH_V8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vaddwev_d_wu_w, LARCH_V2DI_FTYPE_UV4SI_V4SI), ++ LSX_BUILTIN (vaddwev_w_hu_h, LARCH_V4SI_FTYPE_UV8HI_V8HI), ++ LSX_BUILTIN (vaddwev_h_bu_b, LARCH_V8HI_FTYPE_UV16QI_V16QI), ++ LSX_BUILTIN (vaddwod_d_wu_w, LARCH_V2DI_FTYPE_UV4SI_V4SI), ++ LSX_BUILTIN (vaddwod_w_hu_h, LARCH_V4SI_FTYPE_UV8HI_V8HI), ++ LSX_BUILTIN (vaddwod_h_bu_b, LARCH_V8HI_FTYPE_UV16QI_V16QI), ++ LSX_BUILTIN (vsubwev_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsubwev_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsubwev_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsubwod_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vsubwod_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vsubwod_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vsubwev_d_wu, LARCH_V2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vsubwev_w_hu, LARCH_V4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vsubwev_h_bu, LARCH_V8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vsubwod_d_wu, LARCH_V2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vsubwod_w_hu, LARCH_V4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vsubwod_h_bu, LARCH_V8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vaddwev_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vaddwod_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vaddwev_q_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vaddwod_q_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vsubwev_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsubwod_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsubwev_q_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vsubwod_q_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vaddwev_q_du_d, LARCH_V2DI_FTYPE_UV2DI_V2DI), ++ LSX_BUILTIN (vaddwod_q_du_d, LARCH_V2DI_FTYPE_UV2DI_V2DI), ++ ++ LSX_BUILTIN (vmulwev_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vmulwev_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vmulwev_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vmulwod_d_w, LARCH_V2DI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vmulwod_w_h, LARCH_V4SI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vmulwod_h_b, LARCH_V8HI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vmulwev_d_wu, LARCH_V2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vmulwev_w_hu, LARCH_V4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vmulwev_h_bu, LARCH_V8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vmulwod_d_wu, LARCH_V2DI_FTYPE_UV4SI_UV4SI), ++ LSX_BUILTIN (vmulwod_w_hu, LARCH_V4SI_FTYPE_UV8HI_UV8HI), ++ LSX_BUILTIN (vmulwod_h_bu, LARCH_V8HI_FTYPE_UV16QI_UV16QI), ++ LSX_BUILTIN (vmulwev_d_wu_w, LARCH_V2DI_FTYPE_UV4SI_V4SI), ++ LSX_BUILTIN (vmulwev_w_hu_h, LARCH_V4SI_FTYPE_UV8HI_V8HI), ++ LSX_BUILTIN (vmulwev_h_bu_b, LARCH_V8HI_FTYPE_UV16QI_V16QI), ++ LSX_BUILTIN (vmulwod_d_wu_w, LARCH_V2DI_FTYPE_UV4SI_V4SI), ++ LSX_BUILTIN (vmulwod_w_hu_h, LARCH_V4SI_FTYPE_UV8HI_V8HI), ++ LSX_BUILTIN (vmulwod_h_bu_b, LARCH_V8HI_FTYPE_UV16QI_V16QI), ++ LSX_BUILTIN (vmulwev_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vmulwod_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vmulwev_q_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vmulwod_q_du, LARCH_V2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vmulwev_q_du_d, LARCH_V2DI_FTYPE_UV2DI_V2DI), ++ LSX_BUILTIN (vmulwod_q_du_d, LARCH_V2DI_FTYPE_UV2DI_V2DI), ++ LSX_BUILTIN (vhaddw_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vhaddw_qu_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vhsubw_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vhsubw_qu_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI), ++ LSX_BUILTIN (vmaddwev_d_w, LARCH_V2DI_FTYPE_V2DI_V4SI_V4SI), ++ LSX_BUILTIN (vmaddwev_w_h, LARCH_V4SI_FTYPE_V4SI_V8HI_V8HI), ++ LSX_BUILTIN (vmaddwev_h_b, LARCH_V8HI_FTYPE_V8HI_V16QI_V16QI), ++ LSX_BUILTIN (vmaddwev_d_wu, LARCH_UV2DI_FTYPE_UV2DI_UV4SI_UV4SI), ++ LSX_BUILTIN (vmaddwev_w_hu, LARCH_UV4SI_FTYPE_UV4SI_UV8HI_UV8HI), ++ LSX_BUILTIN (vmaddwev_h_bu, LARCH_UV8HI_FTYPE_UV8HI_UV16QI_UV16QI), ++ LSX_BUILTIN (vmaddwod_d_w, LARCH_V2DI_FTYPE_V2DI_V4SI_V4SI), ++ LSX_BUILTIN (vmaddwod_w_h, LARCH_V4SI_FTYPE_V4SI_V8HI_V8HI), ++ LSX_BUILTIN (vmaddwod_h_b, LARCH_V8HI_FTYPE_V8HI_V16QI_V16QI), ++ LSX_BUILTIN (vmaddwod_d_wu, LARCH_UV2DI_FTYPE_UV2DI_UV4SI_UV4SI), ++ LSX_BUILTIN (vmaddwod_w_hu, LARCH_UV4SI_FTYPE_UV4SI_UV8HI_UV8HI), ++ LSX_BUILTIN (vmaddwod_h_bu, LARCH_UV8HI_FTYPE_UV8HI_UV16QI_UV16QI), ++ LSX_BUILTIN (vmaddwev_d_wu_w, LARCH_V2DI_FTYPE_V2DI_UV4SI_V4SI), ++ LSX_BUILTIN (vmaddwev_w_hu_h, LARCH_V4SI_FTYPE_V4SI_UV8HI_V8HI), ++ LSX_BUILTIN (vmaddwev_h_bu_b, LARCH_V8HI_FTYPE_V8HI_UV16QI_V16QI), ++ LSX_BUILTIN (vmaddwod_d_wu_w, LARCH_V2DI_FTYPE_V2DI_UV4SI_V4SI), ++ LSX_BUILTIN (vmaddwod_w_hu_h, LARCH_V4SI_FTYPE_V4SI_UV8HI_V8HI), ++ LSX_BUILTIN (vmaddwod_h_bu_b, LARCH_V8HI_FTYPE_V8HI_UV16QI_V16QI), ++ LSX_BUILTIN (vmaddwev_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI_V2DI), ++ LSX_BUILTIN (vmaddwod_q_d, LARCH_V2DI_FTYPE_V2DI_V2DI_V2DI), ++ LSX_BUILTIN (vmaddwev_q_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI_UV2DI), ++ LSX_BUILTIN (vmaddwod_q_du, LARCH_UV2DI_FTYPE_UV2DI_UV2DI_UV2DI), ++ LSX_BUILTIN (vmaddwev_q_du_d, LARCH_V2DI_FTYPE_V2DI_UV2DI_V2DI), ++ LSX_BUILTIN (vmaddwod_q_du_d, LARCH_V2DI_FTYPE_V2DI_UV2DI_V2DI), ++ LSX_BUILTIN (vrotr_b, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vrotr_h, LARCH_V8HI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vrotr_w, LARCH_V4SI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vrotr_d, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vadd_q, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vsub_q, LARCH_V2DI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vldrepl_b, LARCH_V16QI_FTYPE_CVPOINTER_SI), ++ LSX_BUILTIN (vldrepl_h, LARCH_V8HI_FTYPE_CVPOINTER_SI), ++ LSX_BUILTIN (vldrepl_w, LARCH_V4SI_FTYPE_CVPOINTER_SI), ++ LSX_BUILTIN (vldrepl_d, LARCH_V2DI_FTYPE_CVPOINTER_SI), ++ ++ LSX_BUILTIN (vmskgez_b, LARCH_V16QI_FTYPE_V16QI), ++ LSX_BUILTIN (vmsknz_b, LARCH_V16QI_FTYPE_V16QI), ++ LSX_BUILTIN (vexth_h_b, LARCH_V8HI_FTYPE_V16QI), ++ LSX_BUILTIN (vexth_w_h, LARCH_V4SI_FTYPE_V8HI), ++ LSX_BUILTIN (vexth_d_w, LARCH_V2DI_FTYPE_V4SI), ++ LSX_BUILTIN (vexth_q_d, LARCH_V2DI_FTYPE_V2DI), ++ LSX_BUILTIN (vexth_hu_bu, LARCH_UV8HI_FTYPE_UV16QI), ++ LSX_BUILTIN (vexth_wu_hu, LARCH_UV4SI_FTYPE_UV8HI), ++ LSX_BUILTIN (vexth_du_wu, LARCH_UV2DI_FTYPE_UV4SI), ++ LSX_BUILTIN (vexth_qu_du, LARCH_UV2DI_FTYPE_UV2DI), ++ LSX_BUILTIN (vrotri_b, LARCH_V16QI_FTYPE_V16QI_UQI), ++ LSX_BUILTIN (vrotri_h, LARCH_V8HI_FTYPE_V8HI_UQI), ++ LSX_BUILTIN (vrotri_w, LARCH_V4SI_FTYPE_V4SI_UQI), ++ LSX_BUILTIN (vrotri_d, LARCH_V2DI_FTYPE_V2DI_UQI), ++ LSX_BUILTIN (vextl_q_d, LARCH_V2DI_FTYPE_V2DI), ++ LSX_BUILTIN (vsrlni_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vsrlni_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vsrlni_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vsrlni_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vsrlrni_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vsrlrni_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vsrlrni_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vsrlrni_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vssrlni_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vssrlni_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vssrlni_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vssrlni_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vssrlni_bu_h, LARCH_UV16QI_FTYPE_UV16QI_V16QI_USI), ++ LSX_BUILTIN (vssrlni_hu_w, LARCH_UV8HI_FTYPE_UV8HI_V8HI_USI), ++ LSX_BUILTIN (vssrlni_wu_d, LARCH_UV4SI_FTYPE_UV4SI_V4SI_USI), ++ LSX_BUILTIN (vssrlni_du_q, LARCH_UV2DI_FTYPE_UV2DI_V2DI_USI), ++ LSX_BUILTIN (vssrlrni_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vssrlrni_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vssrlrni_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vssrlrni_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vssrlrni_bu_h, LARCH_UV16QI_FTYPE_UV16QI_V16QI_USI), ++ LSX_BUILTIN (vssrlrni_hu_w, LARCH_UV8HI_FTYPE_UV8HI_V8HI_USI), ++ LSX_BUILTIN (vssrlrni_wu_d, LARCH_UV4SI_FTYPE_UV4SI_V4SI_USI), ++ LSX_BUILTIN (vssrlrni_du_q, LARCH_UV2DI_FTYPE_UV2DI_V2DI_USI), ++ LSX_BUILTIN (vsrani_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vsrani_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vsrani_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vsrani_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vsrarni_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vsrarni_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vsrarni_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vsrarni_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vssrani_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vssrani_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vssrani_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vssrani_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vssrani_bu_h, LARCH_UV16QI_FTYPE_UV16QI_V16QI_USI), ++ LSX_BUILTIN (vssrani_hu_w, LARCH_UV8HI_FTYPE_UV8HI_V8HI_USI), ++ LSX_BUILTIN (vssrani_wu_d, LARCH_UV4SI_FTYPE_UV4SI_V4SI_USI), ++ LSX_BUILTIN (vssrani_du_q, LARCH_UV2DI_FTYPE_UV2DI_V2DI_USI), ++ LSX_BUILTIN (vssrarni_b_h, LARCH_V16QI_FTYPE_V16QI_V16QI_USI), ++ LSX_BUILTIN (vssrarni_h_w, LARCH_V8HI_FTYPE_V8HI_V8HI_USI), ++ LSX_BUILTIN (vssrarni_w_d, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vssrarni_d_q, LARCH_V2DI_FTYPE_V2DI_V2DI_USI), ++ LSX_BUILTIN (vssrarni_bu_h, LARCH_UV16QI_FTYPE_UV16QI_V16QI_USI), ++ LSX_BUILTIN (vssrarni_hu_w, LARCH_UV8HI_FTYPE_UV8HI_V8HI_USI), ++ LSX_BUILTIN (vssrarni_wu_d, LARCH_UV4SI_FTYPE_UV4SI_V4SI_USI), ++ LSX_BUILTIN (vssrarni_du_q, LARCH_UV2DI_FTYPE_UV2DI_V2DI_USI), ++ LSX_BUILTIN (vpermi_w, LARCH_V4SI_FTYPE_V4SI_V4SI_USI), ++ LSX_BUILTIN (vld, LARCH_V16QI_FTYPE_CVPOINTER_SI), ++ LSX_NO_TARGET_BUILTIN (vst, LARCH_VOID_FTYPE_V16QI_CVPOINTER_SI), ++ LSX_BUILTIN (vssrlrn_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vssrlrn_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vssrlrn_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vssrln_b_h, LARCH_V16QI_FTYPE_V8HI_V8HI), ++ LSX_BUILTIN (vssrln_h_w, LARCH_V8HI_FTYPE_V4SI_V4SI), ++ LSX_BUILTIN (vssrln_w_d, LARCH_V4SI_FTYPE_V2DI_V2DI), ++ LSX_BUILTIN (vorn_v, LARCH_V16QI_FTYPE_V16QI_V16QI), ++ LSX_BUILTIN (vldi, LARCH_V2DI_FTYPE_HI), ++ LSX_BUILTIN (vshuf_b, LARCH_V16QI_FTYPE_V16QI_V16QI_V16QI), ++ LSX_BUILTIN (vldx, LARCH_V16QI_FTYPE_CVPOINTER_DI), ++ LSX_NO_TARGET_BUILTIN (vstx, LARCH_VOID_FTYPE_V16QI_CVPOINTER_DI), ++ LSX_BUILTIN (vextl_qu_du, LARCH_UV2DI_FTYPE_UV2DI) + }; + + /* Index I is the function declaration for loongarch_builtinsI, or null if +@@ -193,11 +1219,46 @@ static GTY (()) tree loongarch_builtin_declsARRAY_SIZE (loongarch_builtins); + using the instruction code or return null if not defined for the target. */ + static GTY (()) int loongarch_get_builtin_decl_indexNUM_INSN_CODES; + ++ ++/* MODE is a vector mode whose elements have type TYPE. Return the type ++ of the vector itself. */ ++ ++static tree ++loongarch_builtin_vector_type (tree type, machine_mode mode) ++{ ++ static tree types2 * (int) MAX_MACHINE_MODE; ++ int mode_index; ++ ++ mode_index = (int) mode; ++ ++ if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type)) ++ mode_index += MAX_MACHINE_MODE; ++ ++ if (typesmode_index == NULL_TREE) ++ typesmode_index = build_vector_type_for_mode (type, mode); ++ return typesmode_index; ++} ++ ++/* Return a type for 'const volatile void *'. */ ++ ++static tree ++loongarch_build_cvpointer_type (void) ++{ ++ static tree cache; ++ ++ if (cache == NULL_TREE) ++ cache = build_pointer_type (build_qualified_type (void_type_node, ++ TYPE_QUAL_CONST ++ | TYPE_QUAL_VOLATILE)); ++ return cache; ++} ++ + /* Source-level argument types. */ + #define LARCH_ATYPE_VOID void_type_node + #define LARCH_ATYPE_INT integer_type_node + #define LARCH_ATYPE_POINTER ptr_type_node +- ++#define LARCH_ATYPE_CVPOINTER loongarch_build_cvpointer_type () ++#define LARCH_ATYPE_BOOLEAN boolean_type_node + /* Standard mode-based argument types. */ + #define LARCH_ATYPE_QI intQI_type_node + #define LARCH_ATYPE_UQI unsigned_intQI_type_node +@@ -210,6 +1271,72 @@ static GTY (()) int loongarch_get_builtin_decl_indexNUM_INSN_CODES; + #define LARCH_ATYPE_SF float_type_node + #define LARCH_ATYPE_DF double_type_node + ++/* Vector argument types. */ ++#define LARCH_ATYPE_V2SF \ ++ loongarch_builtin_vector_type (float_type_node, V2SFmode) ++#define LARCH_ATYPE_V2HI \ ++ loongarch_builtin_vector_type (intHI_type_node, V2HImode) ++#define LARCH_ATYPE_V2SI \ ++ loongarch_builtin_vector_type (intSI_type_node, V2SImode) ++#define LARCH_ATYPE_V4QI \ ++ loongarch_builtin_vector_type (intQI_type_node, V4QImode) ++#define LARCH_ATYPE_V4HI \ ++ loongarch_builtin_vector_type (intHI_type_node, V4HImode) ++#define LARCH_ATYPE_V8QI \ ++ loongarch_builtin_vector_type (intQI_type_node, V8QImode) ++ ++#define LARCH_ATYPE_V2DI \ ++ loongarch_builtin_vector_type (long_long_integer_type_node, V2DImode) ++#define LARCH_ATYPE_V4SI \ ++ loongarch_builtin_vector_type (intSI_type_node, V4SImode) ++#define LARCH_ATYPE_V8HI \ ++ loongarch_builtin_vector_type (intHI_type_node, V8HImode) ++#define LARCH_ATYPE_V16QI \ ++ loongarch_builtin_vector_type (intQI_type_node, V16QImode) ++#define LARCH_ATYPE_V2DF \ ++ loongarch_builtin_vector_type (double_type_node, V2DFmode) ++#define LARCH_ATYPE_V4SF \ ++ loongarch_builtin_vector_type (float_type_node, V4SFmode) ++ ++/* LoongArch ASX. */ ++#define LARCH_ATYPE_V4DI \ ++ loongarch_builtin_vector_type (long_long_integer_type_node, V4DImode) ++#define LARCH_ATYPE_V8SI \ ++ loongarch_builtin_vector_type (intSI_type_node, V8SImode) ++#define LARCH_ATYPE_V16HI \ ++ loongarch_builtin_vector_type (intHI_type_node, V16HImode) ++#define LARCH_ATYPE_V32QI \ ++ loongarch_builtin_vector_type (intQI_type_node, V32QImode) ++#define LARCH_ATYPE_V4DF \ ++ loongarch_builtin_vector_type (double_type_node, V4DFmode) ++#define LARCH_ATYPE_V8SF \ ++ loongarch_builtin_vector_type (float_type_node, V8SFmode) ++ ++#define LARCH_ATYPE_UV2DI \ ++ loongarch_builtin_vector_type (long_long_unsigned_type_node, V2DImode) ++#define LARCH_ATYPE_UV4SI \ ++ loongarch_builtin_vector_type (unsigned_intSI_type_node, V4SImode) ++#define LARCH_ATYPE_UV8HI \ ++ loongarch_builtin_vector_type (unsigned_intHI_type_node, V8HImode) ++#define LARCH_ATYPE_UV16QI \ ++ loongarch_builtin_vector_type (unsigned_intQI_type_node, V16QImode) ++ ++#define LARCH_ATYPE_UV4DI \ ++ loongarch_builtin_vector_type (long_long_unsigned_type_node, V4DImode) ++#define LARCH_ATYPE_UV8SI \ ++ loongarch_builtin_vector_type (unsigned_intSI_type_node, V8SImode) ++#define LARCH_ATYPE_UV16HI \ ++ loongarch_builtin_vector_type (unsigned_intHI_type_node, V16HImode) ++#define LARCH_ATYPE_UV32QI \ ++ loongarch_builtin_vector_type (unsigned_intQI_type_node, V32QImode) ++ ++#define LARCH_ATYPE_UV2SI \ ++ loongarch_builtin_vector_type (unsigned_intSI_type_node, V2SImode) ++#define LARCH_ATYPE_UV4HI \ ++ loongarch_builtin_vector_type (unsigned_intHI_type_node, V4HImode) ++#define LARCH_ATYPE_UV8QI \ ++ loongarch_builtin_vector_type (unsigned_intQI_type_node, V8QImode) ++ + /* LARCH_FTYPE_ATYPESN takes N LARCH_FTYPES-like type codes and lists + their associated LARCH_ATYPEs. */ + #define LARCH_FTYPE_ATYPES1(A, B) LARCH_ATYPE_##A, LARCH_ATYPE_##B +@@ -288,6 +1415,92 @@ loongarch_builtin_decl (unsigned int code, bool initialize_p ATTRIBUTE_UNUSED) + return loongarch_builtin_declscode; + } + ++/* Implement TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION. */ ++ ++tree ++loongarch_builtin_vectorized_function (unsigned int fn, tree type_out, ++ tree type_in) ++{ ++ machine_mode in_mode, out_mode; ++ int in_n, out_n; ++ ++ if (TREE_CODE (type_out) != VECTOR_TYPE ++ || TREE_CODE (type_in) != VECTOR_TYPE ++ || !ISA_HAS_LSX) ++ return NULL_TREE; ++ ++ out_mode = TYPE_MODE (TREE_TYPE (type_out)); ++ out_n = TYPE_VECTOR_SUBPARTS (type_out); ++ in_mode = TYPE_MODE (TREE_TYPE (type_in)); ++ in_n = TYPE_VECTOR_SUBPARTS (type_in); ++ ++ /* INSN is the name of the associated instruction pattern, without ++ the leading CODE_FOR_. */ ++#define LARCH_GET_BUILTIN(INSN) \ ++ loongarch_builtin_declsloongarch_get_builtin_decl_indexCODE_FOR_##INSN ++ ++ switch (fn) ++ { ++ CASE_CFN_CEIL: ++ if (out_mode == DFmode && in_mode == DFmode) ++ { ++ if (out_n == 2 && in_n == 2) ++ return LARCH_GET_BUILTIN (lsx_vfrintrp_d); ++ } ++ if (out_mode == SFmode && in_mode == SFmode) ++ { ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lsx_vfrintrp_s); ++ } ++ break; ++ ++ CASE_CFN_TRUNC: ++ if (out_mode == DFmode && in_mode == DFmode) ++ { ++ if (out_n == 2 && in_n == 2) ++ return LARCH_GET_BUILTIN (lsx_vfrintrz_d); ++ } ++ if (out_mode == SFmode && in_mode == SFmode) ++ { ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lsx_vfrintrz_s); ++ } ++ break; ++ ++ CASE_CFN_RINT: ++ CASE_CFN_ROUND: ++ if (out_mode == DFmode && in_mode == DFmode) ++ { ++ if (out_n == 2 && in_n == 2) ++ return LARCH_GET_BUILTIN (lsx_vfrint_d); ++ } ++ if (out_mode == SFmode && in_mode == SFmode) ++ { ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lsx_vfrint_s); ++ } ++ break; ++ ++ CASE_CFN_FLOOR: ++ if (out_mode == DFmode && in_mode == DFmode) ++ { ++ if (out_n == 2 && in_n == 2) ++ return LARCH_GET_BUILTIN (lsx_vfrintrm_d); ++ } ++ if (out_mode == SFmode && in_mode == SFmode) ++ { ++ if (out_n == 4 && in_n == 4) ++ return LARCH_GET_BUILTIN (lsx_vfrintrm_s); ++ } ++ break; ++ ++ default: ++ break; ++ } ++ ++ return NULL_TREE; ++} ++ + /* Take argument ARGNO from EXP's argument list and convert it into + an expand operand. Store the operand in *OP. */ + +@@ -323,7 +1536,236 @@ static rtx + loongarch_expand_builtin_insn (enum insn_code icode, unsigned int nops, + struct expand_operand *ops, bool has_target_p) + { +- if (!maybe_expand_insn (icode, nops, ops)) ++ machine_mode imode; ++ int rangelo = 0, rangehi = 0, error_opno = 0; ++ ++ switch (icode) ++ { ++ case CODE_FOR_lsx_vaddi_bu: ++ case CODE_FOR_lsx_vaddi_hu: ++ case CODE_FOR_lsx_vaddi_wu: ++ case CODE_FOR_lsx_vaddi_du: ++ case CODE_FOR_lsx_vslti_bu: ++ case CODE_FOR_lsx_vslti_hu: ++ case CODE_FOR_lsx_vslti_wu: ++ case CODE_FOR_lsx_vslti_du: ++ case CODE_FOR_lsx_vslei_bu: ++ case CODE_FOR_lsx_vslei_hu: ++ case CODE_FOR_lsx_vslei_wu: ++ case CODE_FOR_lsx_vslei_du: ++ case CODE_FOR_lsx_vmaxi_bu: ++ case CODE_FOR_lsx_vmaxi_hu: ++ case CODE_FOR_lsx_vmaxi_wu: ++ case CODE_FOR_lsx_vmaxi_du: ++ case CODE_FOR_lsx_vmini_bu: ++ case CODE_FOR_lsx_vmini_hu: ++ case CODE_FOR_lsx_vmini_wu: ++ case CODE_FOR_lsx_vmini_du: ++ case CODE_FOR_lsx_vsubi_bu: ++ case CODE_FOR_lsx_vsubi_hu: ++ case CODE_FOR_lsx_vsubi_wu: ++ case CODE_FOR_lsx_vsubi_du: ++ gcc_assert (has_target_p && nops == 3); ++ /* We only generate a vector of constants iff the second argument ++ is an immediate. We also validate the range of the immediate. */ ++ if (CONST_INT_P (ops2.value)) ++ { ++ rangelo = 0; ++ rangehi = 31; ++ if (IN_RANGE (INTVAL (ops2.value), rangelo, rangehi)) ++ { ++ ops2.mode = ops0.mode; ++ ops2.value = loongarch_gen_const_int_vector (ops2.mode, ++ INTVAL (ops2.value)); ++ } ++ else ++ error_opno = 2; ++ } ++ break; ++ ++ case CODE_FOR_lsx_vseqi_b: ++ case CODE_FOR_lsx_vseqi_h: ++ case CODE_FOR_lsx_vseqi_w: ++ case CODE_FOR_lsx_vseqi_d: ++ case CODE_FOR_lsx_vslti_b: ++ case CODE_FOR_lsx_vslti_h: ++ case CODE_FOR_lsx_vslti_w: ++ case CODE_FOR_lsx_vslti_d: ++ case CODE_FOR_lsx_vslei_b: ++ case CODE_FOR_lsx_vslei_h: ++ case CODE_FOR_lsx_vslei_w: ++ case CODE_FOR_lsx_vslei_d: ++ case CODE_FOR_lsx_vmaxi_b: ++ case CODE_FOR_lsx_vmaxi_h: ++ case CODE_FOR_lsx_vmaxi_w: ++ case CODE_FOR_lsx_vmaxi_d: ++ case CODE_FOR_lsx_vmini_b: ++ case CODE_FOR_lsx_vmini_h: ++ case CODE_FOR_lsx_vmini_w: ++ case CODE_FOR_lsx_vmini_d: ++ gcc_assert (has_target_p && nops == 3); ++ /* We only generate a vector of constants iff the second argument ++ is an immediate. We also validate the range of the immediate. */ ++ if (CONST_INT_P (ops2.value)) ++ { ++ rangelo = -16; ++ rangehi = 15; ++ if (IN_RANGE (INTVAL (ops2.value), rangelo, rangehi)) ++ { ++ ops2.mode = ops0.mode; ++ ops2.value = loongarch_gen_const_int_vector (ops2.mode, ++ INTVAL (ops2.value)); ++ } ++ else ++ error_opno = 2; ++ } ++ break; ++ ++ case CODE_FOR_lsx_vandi_b: ++ case CODE_FOR_lsx_vori_b: ++ case CODE_FOR_lsx_vnori_b: ++ case CODE_FOR_lsx_vxori_b: ++ gcc_assert (has_target_p && nops == 3); ++ if (!CONST_INT_P (ops2.value)) ++ break; ++ ops2.mode = ops0.mode; ++ ops2.value = loongarch_gen_const_int_vector (ops2.mode, ++ INTVAL (ops2.value)); ++ break; ++ ++ case CODE_FOR_lsx_vbitseli_b: ++ gcc_assert (has_target_p && nops == 4); ++ if (!CONST_INT_P (ops3.value)) ++ break; ++ ops3.mode = ops0.mode; ++ ops3.value = loongarch_gen_const_int_vector (ops3.mode, ++ INTVAL (ops3.value)); ++ break; ++ ++ case CODE_FOR_lsx_vreplgr2vr_b: ++ case CODE_FOR_lsx_vreplgr2vr_h: ++ case CODE_FOR_lsx_vreplgr2vr_w: ++ case CODE_FOR_lsx_vreplgr2vr_d: ++ /* Map the built-ins to vector fill operations. We need fix up the mode ++ for the element being inserted. */ ++ gcc_assert (has_target_p && nops == 2); ++ imode = GET_MODE_INNER (ops0.mode); ++ ops1.value = lowpart_subreg (imode, ops1.value, ops1.mode); ++ ops1.mode = imode; ++ break; ++ ++ case CODE_FOR_lsx_vilvh_b: ++ case CODE_FOR_lsx_vilvh_h: ++ case CODE_FOR_lsx_vilvh_w: ++ case CODE_FOR_lsx_vilvh_d: ++ case CODE_FOR_lsx_vilvl_b: ++ case CODE_FOR_lsx_vilvl_h: ++ case CODE_FOR_lsx_vilvl_w: ++ case CODE_FOR_lsx_vilvl_d: ++ case CODE_FOR_lsx_vpackev_b: ++ case CODE_FOR_lsx_vpackev_h: ++ case CODE_FOR_lsx_vpackev_w: ++ case CODE_FOR_lsx_vpackod_b: ++ case CODE_FOR_lsx_vpackod_h: ++ case CODE_FOR_lsx_vpackod_w: ++ case CODE_FOR_lsx_vpickev_b: ++ case CODE_FOR_lsx_vpickev_h: ++ case CODE_FOR_lsx_vpickev_w: ++ case CODE_FOR_lsx_vpickod_b: ++ case CODE_FOR_lsx_vpickod_h: ++ case CODE_FOR_lsx_vpickod_w: ++ /* Swap the operands 1 and 2 for interleave operations. Built-ins follow ++ convention of ISA, which have op1 as higher component and op2 as lower ++ component. However, the VEC_PERM op in tree and vec_concat in RTL ++ expects first operand to be lower component, because of which this ++ swap is needed for builtins. */ ++ gcc_assert (has_target_p && nops == 3); ++ std::swap (ops1, ops2); ++ break; ++ ++ case CODE_FOR_lsx_vslli_b: ++ case CODE_FOR_lsx_vslli_h: ++ case CODE_FOR_lsx_vslli_w: ++ case CODE_FOR_lsx_vslli_d: ++ case CODE_FOR_lsx_vsrai_b: ++ case CODE_FOR_lsx_vsrai_h: ++ case CODE_FOR_lsx_vsrai_w: ++ case CODE_FOR_lsx_vsrai_d: ++ case CODE_FOR_lsx_vsrli_b: ++ case CODE_FOR_lsx_vsrli_h: ++ case CODE_FOR_lsx_vsrli_w: ++ case CODE_FOR_lsx_vsrli_d: ++ gcc_assert (has_target_p && nops == 3); ++ if (CONST_INT_P (ops2.value)) ++ { ++ rangelo = 0; ++ rangehi = GET_MODE_UNIT_BITSIZE (ops0.mode) - 1; ++ if (IN_RANGE (INTVAL (ops2.value), rangelo, rangehi)) ++ { ++ ops2.mode = ops0.mode; ++ ops2.value = loongarch_gen_const_int_vector (ops2.mode, ++ INTVAL (ops2.value)); ++ } ++ else ++ error_opno = 2; ++ } ++ break; ++ ++ case CODE_FOR_lsx_vinsgr2vr_b: ++ case CODE_FOR_lsx_vinsgr2vr_h: ++ case CODE_FOR_lsx_vinsgr2vr_w: ++ case CODE_FOR_lsx_vinsgr2vr_d: ++ /* Map the built-ins to insert operations. We need to swap operands, ++ fix up the mode for the element being inserted, and generate ++ a bit mask for vec_merge. */ ++ gcc_assert (has_target_p && nops == 4); ++ std::swap (ops1, ops2); ++ imode = GET_MODE_INNER (ops0.mode); ++ ops1.value = lowpart_subreg (imode, ops1.value, ops1.mode); ++ ops1.mode = imode; ++ rangelo = 0; ++ rangehi = GET_MODE_NUNITS (ops0.mode) - 1; ++ if (CONST_INT_P (ops3.value) ++ && IN_RANGE (INTVAL (ops3.value), rangelo, rangehi)) ++ ops3.value = GEN_INT (1 << INTVAL (ops3.value)); ++ else ++ error_opno = 2; ++ break; ++ ++ /* Map the built-ins to element insert operations. We need to swap ++ operands and generate a bit mask. */ ++ gcc_assert (has_target_p && nops == 4); ++ std::swap (ops1, ops2); ++ std::swap (ops1, ops3); ++ rangelo = 0; ++ rangehi = GET_MODE_NUNITS (ops0.mode) - 1; ++ if (CONST_INT_P (ops3.value) ++ && IN_RANGE (INTVAL (ops3.value), rangelo, rangehi)) ++ ops3.value = GEN_INT (1 << INTVAL (ops3.value)); ++ else ++ error_opno = 2; ++ break; ++ ++ case CODE_FOR_lsx_vshuf4i_b: ++ case CODE_FOR_lsx_vshuf4i_h: ++ case CODE_FOR_lsx_vshuf4i_w: ++ case CODE_FOR_lsx_vshuf4i_w_f: ++ gcc_assert (has_target_p && nops == 3); ++ ops2.value = loongarch_gen_const_int_vector_shuffle (ops0.mode, ++ INTVAL (ops2.value)); ++ break; ++ ++ default: ++ break; ++ } ++ ++ if (error_opno != 0) ++ { ++ error ("argument %d to the built-in must be a constant" ++ " in range %d to %d", error_opno, rangelo, rangehi); ++ return has_target_p ? gen_reg_rtx (ops0.mode) : const0_rtx; ++ } ++ else if (!maybe_expand_insn (icode, nops, ops)) + { + error ("invalid argument to built-in function"); + return has_target_p ? gen_reg_rtx (ops0.mode) : const0_rtx; +@@ -357,6 +1799,50 @@ loongarch_expand_builtin_direct (enum insn_code icode, rtx target, tree exp, + return loongarch_expand_builtin_insn (icode, opno, ops, has_target_p); + } + ++/* Expand an LSX built-in for a compare and branch instruction specified by ++ ICODE, set a general-purpose register to 1 if the branch was taken, ++ 0 otherwise. */ ++ ++static rtx ++loongarch_expand_builtin_lsx_test_branch (enum insn_code icode, tree exp) ++{ ++ struct expand_operand ops3; ++ rtx_insn *cbranch; ++ rtx_code_label *true_label, *done_label; ++ rtx cmp_result; ++ ++ true_label = gen_label_rtx (); ++ done_label = gen_label_rtx (); ++ ++ create_input_operand (&ops0, true_label, TYPE_MODE (TREE_TYPE (exp))); ++ loongarch_prepare_builtin_arg (&ops1, exp, 0); ++ create_fixed_operand (&ops2, const0_rtx); ++ ++ /* Make sure that the operand 1 is a REG. */ ++ if (GET_CODE (ops1.value) != REG) ++ ops1.value = force_reg (ops1.mode, ops1.value); ++ ++ if ((cbranch = maybe_gen_insn (icode, 3, ops)) == NULL_RTX) ++ error ("failed to expand built-in function"); ++ ++ cmp_result = gen_reg_rtx (SImode); ++ ++ /* First assume that CMP_RESULT is false. */ ++ loongarch_emit_move (cmp_result, const0_rtx); ++ ++ /* Branch to TRUE_LABEL if CBRANCH is taken and DONE_LABEL otherwise. */ ++ emit_jump_insn (cbranch); ++ emit_jump_insn (gen_jump (done_label)); ++ emit_barrier (); ++ ++ /* Set CMP_RESULT to true if the branch was taken. */ ++ emit_label (true_label); ++ loongarch_emit_move (cmp_result, const1_rtx); ++ ++ emit_label (done_label); ++ return cmp_result; ++} ++ + /* Implement TARGET_EXPAND_BUILTIN. */ + + rtx +@@ -377,10 +1863,14 @@ loongarch_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED, + switch (d->builtin_type) + { + case LARCH_BUILTIN_DIRECT: ++ case LARCH_BUILTIN_LSX: + return loongarch_expand_builtin_direct (d->icode, target, exp, true); + + case LARCH_BUILTIN_DIRECT_NO_TARGET: + return loongarch_expand_builtin_direct (d->icode, target, exp, false); ++ ++ case LARCH_BUILTIN_LSX_TEST_BRANCH: ++ return loongarch_expand_builtin_lsx_test_branch (d->icode, exp); + } + gcc_unreachable (); + } +diff --git a/gcc/config/loongarch/loongarch-ftypes.def b/gcc/config/loongarch/loongarch-ftypes.def +index 2babff414..2b0d50892 100644 +--- a/gcc/config/loongarch/loongarch-ftypes.def ++++ b/gcc/config/loongarch/loongarch-ftypes.def +@@ -32,7 +32,7 @@ along with GCC; see the file COPYING3. If not see + INT for integer_type_node + POINTER for ptr_type_node + +- (we don't use PTR because that's a ANSI-compatibillity macro). ++ (we don't use PTR because that's a ANSI-compatibility macro). + + Please keep this list lexicographically sorted by the LIST argument. */ + +@@ -63,3 +63,396 @@ DEF_LARCH_FTYPE (3, (VOID, USI, USI, SI)) + DEF_LARCH_FTYPE (3, (VOID, USI, UDI, SI)) + DEF_LARCH_FTYPE (3, (USI, USI, USI, USI)) + DEF_LARCH_FTYPE (3, (UDI, UDI, UDI, USI)) ++ ++DEF_LARCH_FTYPE (1, (DF, DF)) ++DEF_LARCH_FTYPE (2, (DF, DF, DF)) ++DEF_LARCH_FTYPE (1, (DF, V2DF)) ++ ++DEF_LARCH_FTYPE (1, (DI, DI)) ++DEF_LARCH_FTYPE (1, (DI, SI)) ++DEF_LARCH_FTYPE (1, (DI, UQI)) ++DEF_LARCH_FTYPE (2, (DI, DI, DI)) ++DEF_LARCH_FTYPE (2, (DI, DI, SI)) ++DEF_LARCH_FTYPE (3, (DI, DI, SI, SI)) ++DEF_LARCH_FTYPE (3, (DI, DI, USI, USI)) ++DEF_LARCH_FTYPE (3, (DI, DI, DI, QI)) ++DEF_LARCH_FTYPE (3, (DI, DI, V2HI, V2HI)) ++DEF_LARCH_FTYPE (3, (DI, DI, V4QI, V4QI)) ++DEF_LARCH_FTYPE (2, (DI, POINTER, SI)) ++DEF_LARCH_FTYPE (2, (DI, SI, SI)) ++DEF_LARCH_FTYPE (2, (DI, USI, USI)) ++ ++DEF_LARCH_FTYPE (2, (DI, V2DI, UQI)) ++ ++DEF_LARCH_FTYPE (2, (INT, DF, DF)) ++DEF_LARCH_FTYPE (2, (INT, SF, SF)) ++ ++DEF_LARCH_FTYPE (2, (INT, V2SF, V2SF)) ++DEF_LARCH_FTYPE (4, (INT, V2SF, V2SF, V2SF, V2SF)) ++ ++DEF_LARCH_FTYPE (1, (SF, SF)) ++DEF_LARCH_FTYPE (2, (SF, SF, SF)) ++DEF_LARCH_FTYPE (1, (SF, V2SF)) ++DEF_LARCH_FTYPE (1, (SF, V4SF)) ++ ++DEF_LARCH_FTYPE (2, (SI, POINTER, SI)) ++DEF_LARCH_FTYPE (1, (SI, SI)) ++DEF_LARCH_FTYPE (1, (SI, UDI)) ++DEF_LARCH_FTYPE (2, (QI, QI, QI)) ++DEF_LARCH_FTYPE (2, (HI, HI, HI)) ++DEF_LARCH_FTYPE (3, (SI, SI, SI, SI)) ++DEF_LARCH_FTYPE (3, (SI, SI, SI, QI)) ++DEF_LARCH_FTYPE (1, (SI, UQI)) ++DEF_LARCH_FTYPE (1, (SI, UV16QI)) ++DEF_LARCH_FTYPE (1, (SI, UV2DI)) ++DEF_LARCH_FTYPE (1, (SI, UV4SI)) ++DEF_LARCH_FTYPE (1, (SI, UV8HI)) ++DEF_LARCH_FTYPE (2, (SI, V16QI, UQI)) ++DEF_LARCH_FTYPE (1, (SI, V2HI)) ++DEF_LARCH_FTYPE (2, (SI, V2HI, V2HI)) ++DEF_LARCH_FTYPE (1, (SI, V4QI)) ++DEF_LARCH_FTYPE (2, (SI, V4QI, V4QI)) ++DEF_LARCH_FTYPE (2, (SI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (SI, V8HI, UQI)) ++DEF_LARCH_FTYPE (1, (SI, VOID)) ++ ++DEF_LARCH_FTYPE (2, (UDI, UDI, UDI)) ++DEF_LARCH_FTYPE (2, (UDI, UV2SI, UV2SI)) ++DEF_LARCH_FTYPE (2, (UDI, V2DI, UQI)) ++ ++DEF_LARCH_FTYPE (2, (USI, V16QI, UQI)) ++DEF_LARCH_FTYPE (2, (USI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (USI, V8HI, UQI)) ++DEF_LARCH_FTYPE (1, (USI, VOID)) ++ ++DEF_LARCH_FTYPE (2, (UV16QI, UV16QI, UQI)) ++DEF_LARCH_FTYPE (2, (UV16QI, UV16QI, USI)) ++DEF_LARCH_FTYPE (2, (UV16QI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (3, (UV16QI, UV16QI, UV16QI, UQI)) ++DEF_LARCH_FTYPE (3, (UV16QI, UV16QI, UV16QI, USI)) ++DEF_LARCH_FTYPE (3, (UV16QI, UV16QI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (2, (UV16QI, UV16QI, V16QI)) ++ ++DEF_LARCH_FTYPE (2, (UV2DI, UV2DI, UQI)) ++DEF_LARCH_FTYPE (2, (UV2DI, UV2DI, UV2DI)) ++DEF_LARCH_FTYPE (3, (UV2DI, UV2DI, UV2DI, UQI)) ++DEF_LARCH_FTYPE (3, (UV2DI, UV2DI, UV2DI, UV2DI)) ++DEF_LARCH_FTYPE (3, (UV2DI, UV2DI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (2, (UV2DI, UV2DI, V2DI)) ++DEF_LARCH_FTYPE (2, (UV2DI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (1, (UV2DI, V2DF)) ++ ++DEF_LARCH_FTYPE (2, (UV2SI, UV2SI, UQI)) ++DEF_LARCH_FTYPE (2, (UV2SI, UV2SI, UV2SI)) ++ ++DEF_LARCH_FTYPE (2, (UV4HI, UV4HI, UQI)) ++DEF_LARCH_FTYPE (2, (UV4HI, UV4HI, USI)) ++DEF_LARCH_FTYPE (2, (UV4HI, UV4HI, UV4HI)) ++DEF_LARCH_FTYPE (3, (UV4HI, UV4HI, UV4HI, UQI)) ++DEF_LARCH_FTYPE (3, (UV4HI, UV4HI, UV4HI, USI)) ++DEF_LARCH_FTYPE (1, (UV4HI, UV8QI)) ++DEF_LARCH_FTYPE (2, (UV4HI, UV8QI, UV8QI)) ++ ++DEF_LARCH_FTYPE (2, (UV4SI, UV4SI, UQI)) ++DEF_LARCH_FTYPE (2, (UV4SI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (3, (UV4SI, UV4SI, UV4SI, UQI)) ++DEF_LARCH_FTYPE (3, (UV4SI, UV4SI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (3, (UV4SI, UV4SI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (UV4SI, UV4SI, V4SI)) ++DEF_LARCH_FTYPE (2, (UV4SI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (1, (UV4SI, V4SF)) ++ ++DEF_LARCH_FTYPE (2, (UV8HI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (2, (UV8HI, UV8HI, UQI)) ++DEF_LARCH_FTYPE (3, (UV8HI, UV8HI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (2, (UV8HI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (3, (UV8HI, UV8HI, UV8HI, UQI)) ++DEF_LARCH_FTYPE (3, (UV8HI, UV8HI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (UV8HI, UV8HI, V8HI)) ++ ++ ++ ++DEF_LARCH_FTYPE (2, (UV8QI, UV4HI, UV4HI)) ++DEF_LARCH_FTYPE (1, (UV8QI, UV8QI)) ++DEF_LARCH_FTYPE (2, (UV8QI, UV8QI, UV8QI)) ++ ++DEF_LARCH_FTYPE (2, (V16QI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (2, (V16QI, CVPOINTER, DI)) ++DEF_LARCH_FTYPE (1, (V16QI, HI)) ++DEF_LARCH_FTYPE (1, (V16QI, SI)) ++DEF_LARCH_FTYPE (2, (V16QI, UV16QI, UQI)) ++DEF_LARCH_FTYPE (2, (V16QI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (1, (V16QI, V16QI)) ++DEF_LARCH_FTYPE (2, (V16QI, V16QI, QI)) ++DEF_LARCH_FTYPE (2, (V16QI, V16QI, SI)) ++DEF_LARCH_FTYPE (2, (V16QI, V16QI, USI)) ++DEF_LARCH_FTYPE (2, (V16QI, V16QI, UQI)) ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, UQI, SI)) ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, UQI, V16QI)) ++DEF_LARCH_FTYPE (2, (V16QI, V16QI, V16QI)) ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, V16QI, SI)) ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, V16QI, UQI)) ++DEF_LARCH_FTYPE (4, (V16QI, V16QI, V16QI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, V16QI, USI)) ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, V16QI, V16QI)) ++ ++ ++DEF_LARCH_FTYPE (1, (V2DF, DF)) ++DEF_LARCH_FTYPE (1, (V2DF, UV2DI)) ++DEF_LARCH_FTYPE (1, (V2DF, V2DF)) ++DEF_LARCH_FTYPE (2, (V2DF, V2DF, V2DF)) ++DEF_LARCH_FTYPE (3, (V2DF, V2DF, V2DF, V2DF)) ++DEF_LARCH_FTYPE (2, (V2DF, V2DF, V2DI)) ++DEF_LARCH_FTYPE (1, (V2DF, V2DI)) ++DEF_LARCH_FTYPE (1, (V2DF, V4SF)) ++DEF_LARCH_FTYPE (1, (V2DF, V4SI)) ++ ++DEF_LARCH_FTYPE (2, (V2DI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (1, (V2DI, DI)) ++DEF_LARCH_FTYPE (1, (V2DI, HI)) ++DEF_LARCH_FTYPE (2, (V2DI, UV2DI, UQI)) ++DEF_LARCH_FTYPE (2, (V2DI, UV2DI, UV2DI)) ++DEF_LARCH_FTYPE (2, (V2DI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (1, (V2DI, V2DF)) ++DEF_LARCH_FTYPE (2, (V2DI, V2DF, V2DF)) ++DEF_LARCH_FTYPE (1, (V2DI, V2DI)) ++DEF_LARCH_FTYPE (1, (UV2DI, UV2DI)) ++DEF_LARCH_FTYPE (2, (V2DI, V2DI, QI)) ++DEF_LARCH_FTYPE (2, (V2DI, V2DI, SI)) ++DEF_LARCH_FTYPE (2, (V2DI, V2DI, UQI)) ++DEF_LARCH_FTYPE (2, (V2DI, V2DI, USI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, UQI, DI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, UQI, V2DI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (2, (V2DI, V2DI, V2DI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, V2DI, SI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, V2DI, UQI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, V2DI, USI)) ++DEF_LARCH_FTYPE (4, (V2DI, V2DI, V2DI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, V2DI, V2DI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, V4SI, V4SI)) ++DEF_LARCH_FTYPE (2, (V2DI, V4SI, V4SI)) ++ ++DEF_LARCH_FTYPE (1, (V2HI, SI)) ++DEF_LARCH_FTYPE (2, (V2HI, SI, SI)) ++DEF_LARCH_FTYPE (3, (V2HI, SI, SI, SI)) ++DEF_LARCH_FTYPE (1, (V2HI, V2HI)) ++DEF_LARCH_FTYPE (2, (V2HI, V2HI, SI)) ++DEF_LARCH_FTYPE (2, (V2HI, V2HI, V2HI)) ++DEF_LARCH_FTYPE (1, (V2HI, V4QI)) ++DEF_LARCH_FTYPE (2, (V2HI, V4QI, V2HI)) ++ ++DEF_LARCH_FTYPE (2, (V2SF, SF, SF)) ++DEF_LARCH_FTYPE (1, (V2SF, V2SF)) ++DEF_LARCH_FTYPE (2, (V2SF, V2SF, V2SF)) ++DEF_LARCH_FTYPE (3, (V2SF, V2SF, V2SF, INT)) ++DEF_LARCH_FTYPE (4, (V2SF, V2SF, V2SF, V2SF, V2SF)) ++ ++DEF_LARCH_FTYPE (2, (V2SI, V2SI, UQI)) ++DEF_LARCH_FTYPE (2, (V2SI, V2SI, V2SI)) ++DEF_LARCH_FTYPE (2, (V2SI, V4HI, V4HI)) ++ ++DEF_LARCH_FTYPE (2, (V4HI, V2SI, V2SI)) ++DEF_LARCH_FTYPE (2, (V4HI, V4HI, UQI)) ++DEF_LARCH_FTYPE (2, (V4HI, V4HI, USI)) ++DEF_LARCH_FTYPE (2, (V4HI, V4HI, V4HI)) ++DEF_LARCH_FTYPE (3, (V4HI, V4HI, V4HI, UQI)) ++DEF_LARCH_FTYPE (3, (V4HI, V4HI, V4HI, USI)) ++ ++DEF_LARCH_FTYPE (1, (V4QI, SI)) ++DEF_LARCH_FTYPE (2, (V4QI, V2HI, V2HI)) ++DEF_LARCH_FTYPE (1, (V4QI, V4QI)) ++DEF_LARCH_FTYPE (2, (V4QI, V4QI, SI)) ++DEF_LARCH_FTYPE (2, (V4QI, V4QI, V4QI)) ++ ++DEF_LARCH_FTYPE (1, (V4SF, SF)) ++DEF_LARCH_FTYPE (1, (V4SF, UV4SI)) ++DEF_LARCH_FTYPE (2, (V4SF, V2DF, V2DF)) ++DEF_LARCH_FTYPE (1, (V4SF, V4SF)) ++DEF_LARCH_FTYPE (2, (V4SF, V4SF, V4SF)) ++DEF_LARCH_FTYPE (3, (V4SF, V4SF, V4SF, V4SF)) ++DEF_LARCH_FTYPE (2, (V4SF, V4SF, V4SI)) ++DEF_LARCH_FTYPE (1, (V4SF, V4SI)) ++DEF_LARCH_FTYPE (1, (V4SF, V8HI)) ++ ++DEF_LARCH_FTYPE (2, (V4SI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (1, (V4SI, HI)) ++DEF_LARCH_FTYPE (1, (V4SI, SI)) ++DEF_LARCH_FTYPE (2, (V4SI, UV4SI, UQI)) ++DEF_LARCH_FTYPE (2, (V4SI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (2, (V4SI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (V4SI, V2DF, V2DF)) ++DEF_LARCH_FTYPE (1, (V4SI, V4SF)) ++DEF_LARCH_FTYPE (2, (V4SI, V4SF, V4SF)) ++DEF_LARCH_FTYPE (1, (V4SI, V4SI)) ++DEF_LARCH_FTYPE (2, (V4SI, V4SI, QI)) ++DEF_LARCH_FTYPE (2, (V4SI, V4SI, SI)) ++DEF_LARCH_FTYPE (2, (V4SI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (V4SI, V4SI, USI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, UQI, SI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, UQI, V4SI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (V4SI, V4SI, V4SI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, V4SI, SI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, V4SI, UQI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, V4SI, USI)) ++DEF_LARCH_FTYPE (4, (V4SI, V4SI, V4SI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, V4SI, V4SI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, V8HI, V8HI)) ++DEF_LARCH_FTYPE (2, (V4SI, V8HI, V8HI)) ++ ++DEF_LARCH_FTYPE (2, (V8HI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (1, (V8HI, HI)) ++DEF_LARCH_FTYPE (1, (V8HI, SI)) ++DEF_LARCH_FTYPE (2, (V8HI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (2, (V8HI, UV8HI, UQI)) ++DEF_LARCH_FTYPE (2, (V8HI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (V8HI, V16QI, V16QI)) ++DEF_LARCH_FTYPE (2, (V8HI, V4SF, V4SF)) ++DEF_LARCH_FTYPE (1, (V8HI, V8HI)) ++DEF_LARCH_FTYPE (2, (V8HI, V8HI, QI)) ++DEF_LARCH_FTYPE (2, (V8HI, V8HI, SI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, SI, UQI)) ++DEF_LARCH_FTYPE (2, (V8HI, V8HI, UQI)) ++DEF_LARCH_FTYPE (2, (V8HI, V8HI, USI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, UQI, SI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, UQI, V8HI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, V16QI, V16QI)) ++DEF_LARCH_FTYPE (2, (V8HI, V8HI, V8HI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, V8HI, SI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, V8HI, UQI)) ++DEF_LARCH_FTYPE (4, (V8HI, V8HI, V8HI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, V8HI, USI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, V8HI, V8HI)) ++ ++DEF_LARCH_FTYPE (2, (V8QI, V4HI, V4HI)) ++DEF_LARCH_FTYPE (1, (V8QI, V8QI)) ++DEF_LARCH_FTYPE (2, (V8QI, V8QI, V8QI)) ++ ++DEF_LARCH_FTYPE (2, (VOID, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (VOID, SI, SI)) ++DEF_LARCH_FTYPE (2, (VOID, UQI, SI)) ++DEF_LARCH_FTYPE (2, (VOID, USI, UQI)) ++DEF_LARCH_FTYPE (1, (VOID, UHI)) ++DEF_LARCH_FTYPE (3, (VOID, V16QI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V16QI, CVPOINTER, DI)) ++DEF_LARCH_FTYPE (3, (VOID, V2DF, POINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V2DI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (2, (VOID, V2HI, V2HI)) ++DEF_LARCH_FTYPE (2, (VOID, V4QI, V4QI)) ++DEF_LARCH_FTYPE (3, (VOID, V4SF, POINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V4SI, CVPOINTER, SI)) ++DEF_LARCH_FTYPE (3, (VOID, V8HI, CVPOINTER, SI)) ++ ++DEF_LARCH_FTYPE (1, (V8HI, V16QI)) ++DEF_LARCH_FTYPE (1, (V4SI, V16QI)) ++DEF_LARCH_FTYPE (1, (V2DI, V16QI)) ++DEF_LARCH_FTYPE (1, (V4SI, V8HI)) ++DEF_LARCH_FTYPE (1, (V2DI, V8HI)) ++DEF_LARCH_FTYPE (1, (V2DI, V4SI)) ++DEF_LARCH_FTYPE (1, (UV8HI, V16QI)) ++DEF_LARCH_FTYPE (1, (UV4SI, V16QI)) ++DEF_LARCH_FTYPE (1, (UV2DI, V16QI)) ++DEF_LARCH_FTYPE (1, (UV4SI, V8HI)) ++DEF_LARCH_FTYPE (1, (UV2DI, V8HI)) ++DEF_LARCH_FTYPE (1, (UV2DI, V4SI)) ++DEF_LARCH_FTYPE (1, (UV8HI, UV16QI)) ++DEF_LARCH_FTYPE (1, (UV4SI, UV16QI)) ++DEF_LARCH_FTYPE (1, (UV2DI, UV16QI)) ++DEF_LARCH_FTYPE (1, (UV4SI, UV8HI)) ++DEF_LARCH_FTYPE (1, (UV2DI, UV8HI)) ++DEF_LARCH_FTYPE (1, (UV2DI, UV4SI)) ++DEF_LARCH_FTYPE (2, (UV8HI, V16QI, V16QI)) ++DEF_LARCH_FTYPE (2, (UV4SI, V8HI, V8HI)) ++DEF_LARCH_FTYPE (2, (UV2DI, V4SI, V4SI)) ++DEF_LARCH_FTYPE (2, (V8HI, V16QI, UQI)) ++DEF_LARCH_FTYPE (2, (V4SI, V8HI, UQI)) ++DEF_LARCH_FTYPE (2, (V2DI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (UV8HI, UV16QI, UQI)) ++DEF_LARCH_FTYPE (2, (UV4SI, UV8HI, UQI)) ++DEF_LARCH_FTYPE (2, (UV2DI, UV4SI, UQI)) ++DEF_LARCH_FTYPE (2, (V16QI, V8HI, V8HI)) ++DEF_LARCH_FTYPE (2, (V8HI, V4SI, V4SI)) ++DEF_LARCH_FTYPE (2, (V4SI, V2DI, V2DI)) ++DEF_LARCH_FTYPE (2, (UV16QI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (UV8HI, UV4SI, UV4SI)) ++DEF_LARCH_FTYPE (2, (UV4SI, UV2DI, UV2DI)) ++DEF_LARCH_FTYPE (2, (V16QI, V8HI, UQI)) ++DEF_LARCH_FTYPE (2, (V8HI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (V4SI, V2DI, UQI)) ++DEF_LARCH_FTYPE (2, (UV16QI, UV8HI, UQI)) ++DEF_LARCH_FTYPE (2, (UV8HI, UV4SI, UQI)) ++DEF_LARCH_FTYPE (2, (UV4SI, UV2DI, UQI)) ++DEF_LARCH_FTYPE (2, (V16QI, V16QI, DI)) ++DEF_LARCH_FTYPE (2, (V16QI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, UQI, UQI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, UQI, UQI)) ++DEF_LARCH_FTYPE (2, (V4SF, V2DI, V2DI)) ++DEF_LARCH_FTYPE (1, (V2DI, V4SF)) ++DEF_LARCH_FTYPE (2, (V2DI, UQI, USI)) ++DEF_LARCH_FTYPE (2, (V2DI, UQI, UQI)) ++DEF_LARCH_FTYPE (4, (VOID, SI, UQI, V16QI, CVPOINTER)) ++DEF_LARCH_FTYPE (4, (VOID, SI, UQI, V8HI, CVPOINTER)) ++DEF_LARCH_FTYPE (4, (VOID, SI, UQI, V4SI, CVPOINTER)) ++DEF_LARCH_FTYPE (4, (VOID, SI, UQI, V2DI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V16QI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V8HI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V4SI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V2DI, SI, CVPOINTER)) ++DEF_LARCH_FTYPE (2, (V8HI, UV16QI, V16QI)) ++DEF_LARCH_FTYPE (2, (V16QI, V16QI, UV16QI)) ++DEF_LARCH_FTYPE (2, (UV16QI, V16QI, UV16QI)) ++DEF_LARCH_FTYPE (2, (V8HI, V8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (UV8HI, V8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (V4SI, V4SI, UV4SI)) ++DEF_LARCH_FTYPE (2, (UV4SI, V4SI, UV4SI)) ++DEF_LARCH_FTYPE (2, (V4SI, V16QI, V16QI)) ++DEF_LARCH_FTYPE (2, (V4SI, UV16QI, V16QI)) ++DEF_LARCH_FTYPE (2, (UV4SI, UV16QI, UV16QI)) ++DEF_LARCH_FTYPE (2, (V2DI, V2DI, UV2DI)) ++DEF_LARCH_FTYPE (2, (UV2DI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (2, (V4SI, UV8HI, V8HI)) ++DEF_LARCH_FTYPE (2, (V2DI, UV4SI, V4SI)) ++DEF_LARCH_FTYPE (2, (V2DI, UV2DI, V2DI)) ++DEF_LARCH_FTYPE (2, (V2DI, V8HI, V8HI)) ++DEF_LARCH_FTYPE (2, (V2DI, UV8HI, V8HI)) ++DEF_LARCH_FTYPE (2, (UV2DI, V2DI, UV2DI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, UV8HI, V8HI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, UV2DI, V2DI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, UV4SI, V4SI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, V8HI, V8HI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, UV8HI, V8HI)) ++DEF_LARCH_FTYPE (3, (UV2DI, UV2DI, UV8HI, UV8HI)) ++DEF_LARCH_FTYPE (3, (V8HI, V8HI, UV16QI, V16QI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, V16QI, V16QI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, UV16QI, V16QI)) ++DEF_LARCH_FTYPE (3, (UV4SI, UV4SI, UV16QI, UV16QI)) ++ ++DEF_LARCH_FTYPE(4,(VOID,V16QI,CVPOINTER,SI,UQI)) ++DEF_LARCH_FTYPE(4,(VOID,V8HI,CVPOINTER,SI,UQI)) ++DEF_LARCH_FTYPE(4,(VOID,V4SI,CVPOINTER,SI,UQI)) ++DEF_LARCH_FTYPE(4,(VOID,V2DI,CVPOINTER,SI,UQI)) ++ ++DEF_LARCH_FTYPE (2, (DI, V16QI, UQI)) ++DEF_LARCH_FTYPE (2, (DI, V8HI, UQI)) ++DEF_LARCH_FTYPE (2, (DI, V4SI, UQI)) ++DEF_LARCH_FTYPE (2, (UDI, V16QI, UQI)) ++DEF_LARCH_FTYPE (2, (UDI, V8HI, UQI)) ++DEF_LARCH_FTYPE (2, (UDI, V4SI, UQI)) ++ ++DEF_LARCH_FTYPE (3, (UV16QI, UV16QI, V16QI, USI)) ++DEF_LARCH_FTYPE (3, (UV8HI, UV8HI, V8HI, USI)) ++DEF_LARCH_FTYPE (3, (UV4SI, UV4SI, V4SI, USI)) ++DEF_LARCH_FTYPE (3, (UV2DI, UV2DI, V2DI, USI)) ++ ++DEF_LARCH_FTYPE (1, (BOOLEAN,V16QI)) ++DEF_LARCH_FTYPE(2,(V16QI,CVPOINTER,CVPOINTER)) ++DEF_LARCH_FTYPE(3,(VOID,V16QI,CVPOINTER,CVPOINTER)) ++ ++DEF_LARCH_FTYPE (3, (V16QI, V16QI, SI, UQI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, SI, UQI)) ++DEF_LARCH_FTYPE (3, (V2DI, V2DI, DI, UQI)) ++DEF_LARCH_FTYPE (3, (V4SI, V4SI, SI, UQI)) +diff --git a/gcc/config/loongarch/lsxintrin.h b/gcc/config/loongarch/lsxintrin.h +new file mode 100644 +index 000000000..ec4206990 +--- /dev/null ++++ b/gcc/config/loongarch/lsxintrin.h +@@ -0,0 +1,5181 @@ ++/* LARCH Loongson SX intrinsics include file. ++ ++ Copyright (C) 2018 Free Software Foundation, Inc. ++ ++ This file is part of GCC. ++ ++ GCC is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published ++ by the Free Software Foundation; either version 3, or (at your ++ option) any later version. ++ ++ GCC is distributed in the hope that it will be useful, but WITHOUT ++ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ++ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public ++ License for more details. ++ ++ Under Section 7 of GPL version 3, you are granted additional ++ permissions described in the GCC Runtime Library Exception, version ++ 3.1, as published by the Free Software Foundation. ++ ++ You should have received a copy of the GNU General Public License and ++ a copy of the GCC Runtime Library Exception along with this program; ++ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see ++ <http://www.gnu.org/licenses/>. */ ++ ++#ifndef _GCC_LOONGSON_SXINTRIN_H ++#define _GCC_LOONGSON_SXINTRIN_H 1 ++ ++#if defined(__loongarch_sx) ++typedef signed char v16i8 __attribute__ ((vector_size(16), aligned(16))); ++typedef signed char v16i8_b __attribute__ ((vector_size(16), aligned(1))); ++typedef unsigned char v16u8 __attribute__ ((vector_size(16), aligned(16))); ++typedef unsigned char v16u8_b __attribute__ ((vector_size(16), aligned(1))); ++typedef short v8i16 __attribute__ ((vector_size(16), aligned(16))); ++typedef short v8i16_h __attribute__ ((vector_size(16), aligned(2))); ++typedef unsigned short v8u16 __attribute__ ((vector_size(16), aligned(16))); ++typedef unsigned short v8u16_h __attribute__ ((vector_size(16), aligned(2))); ++typedef int v4i32 __attribute__ ((vector_size(16), aligned(16))); ++typedef int v4i32_w __attribute__ ((vector_size(16), aligned(4))); ++typedef unsigned int v4u32 __attribute__ ((vector_size(16), aligned(16))); ++typedef unsigned int v4u32_w __attribute__ ((vector_size(16), aligned(4))); ++typedef long long v2i64 __attribute__ ((vector_size(16), aligned(16))); ++typedef long long v2i64_d __attribute__ ((vector_size(16), aligned(8))); ++typedef unsigned long long v2u64 __attribute__ ((vector_size(16), aligned(16))); ++typedef unsigned long long v2u64_d __attribute__ ((vector_size(16), aligned(8))); ++typedef float v4f32 __attribute__ ((vector_size(16), aligned(16))); ++typedef float v4f32_w __attribute__ ((vector_size(16), aligned(4))); ++typedef double v2f64 __attribute__ ((vector_size(16), aligned(16))); ++typedef double v2f64_d __attribute__ ((vector_size(16), aligned(8))); ++ ++typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__)); ++typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__)); ++typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__)); ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsll_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsll_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsll_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsll_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsll_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsll_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsll_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsll_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vslli_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vslli_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vslli_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vslli_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vslli_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslli_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vslli_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vslli_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsra_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsra_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsra_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsra_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsra_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsra_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsra_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsra_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vsrai_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrai_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vsrai_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrai_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vsrai_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrai_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vsrai_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrai_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrar_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrar_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrar_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrar_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrar_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrar_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrar_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrar_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vsrari_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrari_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vsrari_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrari_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vsrari_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrari_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vsrari_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrari_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrl_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrl_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrl_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrl_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrl_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrl_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrl_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrl_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vsrli_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrli_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vsrli_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrli_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vsrli_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrli_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vsrli_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrli_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrlr_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrlr_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrlr_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrlr_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrlr_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrlr_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrlr_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrlr_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vsrlri_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrlri_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vsrlri_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrlri_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vsrlri_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrlri_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vsrlri_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vsrlri_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitclr_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitclr_b ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitclr_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitclr_h ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitclr_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitclr_w ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitclr_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitclr_d ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vbitclri_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitclri_b ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UQI. */ ++#define __lsx_vbitclri_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitclri_h ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UQI. */ ++#define __lsx_vbitclri_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitclri_w ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UQI. */ ++#define __lsx_vbitclri_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitclri_d ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitset_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitset_b ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitset_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitset_h ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitset_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitset_w ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitset_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitset_d ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vbitseti_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitseti_b ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UQI. */ ++#define __lsx_vbitseti_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitseti_h ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UQI. */ ++#define __lsx_vbitseti_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitseti_w ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UQI. */ ++#define __lsx_vbitseti_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitseti_d ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitrev_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitrev_b ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitrev_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitrev_h ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitrev_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitrev_w ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitrev_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vbitrev_d ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vbitrevi_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitrevi_b ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UQI. */ ++#define __lsx_vbitrevi_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitrevi_h ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UQI. */ ++#define __lsx_vbitrevi_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitrevi_w ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UQI. */ ++#define __lsx_vbitrevi_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vbitrevi_d ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadd_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadd_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadd_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadd_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadd_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadd_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadd_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadd_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vaddi_bu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vaddi_bu ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vaddi_hu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vaddi_hu ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vaddi_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vaddi_wu ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vaddi_du(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vaddi_du ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsub_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsub_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsub_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsub_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsub_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsub_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsub_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsub_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vsubi_bu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsubi_bu ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vsubi_hu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsubi_hu ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vsubi_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsubi_wu ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vsubi_du(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsubi_du ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V16QI, V16QI, QI. */ ++#define __lsx_vmaxi_b(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V8HI, V8HI, QI. */ ++#define __lsx_vmaxi_h(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V4SI, V4SI, QI. */ ++#define __lsx_vmaxi_w(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V2DI, V2DI, QI. */ ++#define __lsx_vmaxi_d(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmax_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmax_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vmaxi_bu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_bu ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UQI. */ ++#define __lsx_vmaxi_hu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_hu ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UQI. */ ++#define __lsx_vmaxi_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_wu ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UQI. */ ++#define __lsx_vmaxi_du(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmaxi_du ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V16QI, V16QI, QI. */ ++#define __lsx_vmini_b(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V8HI, V8HI, QI. */ ++#define __lsx_vmini_h(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V4SI, V4SI, QI. */ ++#define __lsx_vmini_w(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V2DI, V2DI, QI. */ ++#define __lsx_vmini_d(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmin_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmin_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vmini_bu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_bu ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UQI. */ ++#define __lsx_vmini_hu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_hu ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UQI. */ ++#define __lsx_vmini_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_wu ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UQI. */ ++#define __lsx_vmini_du(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vmini_du ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vseq_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vseq_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vseq_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vseq_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vseq_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vseq_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vseq_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vseq_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V16QI, V16QI, QI. */ ++#define __lsx_vseqi_b(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vseqi_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V8HI, V8HI, QI. */ ++#define __lsx_vseqi_h(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vseqi_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V4SI, V4SI, QI. */ ++#define __lsx_vseqi_w(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vseqi_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V2DI, V2DI, QI. */ ++#define __lsx_vseqi_d(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vseqi_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V16QI, V16QI, QI. */ ++#define __lsx_vslti_b(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V8HI, V8HI, QI. */ ++#define __lsx_vslti_h(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V4SI, V4SI, QI. */ ++#define __lsx_vslti_w(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V2DI, V2DI, QI. */ ++#define __lsx_vslti_d(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vslt_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vslt_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V16QI, UV16QI, UQI. */ ++#define __lsx_vslti_bu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_bu ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, UV8HI, UQI. */ ++#define __lsx_vslti_hu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_hu ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, UV4SI, UQI. */ ++#define __lsx_vslti_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_wu ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V2DI, UV2DI, UQI. */ ++#define __lsx_vslti_du(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslti_du ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V16QI, V16QI, QI. */ ++#define __lsx_vslei_b(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V8HI, V8HI, QI. */ ++#define __lsx_vslei_h(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V4SI, V4SI, QI. */ ++#define __lsx_vslei_w(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, si5. */ ++/* Data types in instruction templates: V2DI, V2DI, QI. */ ++#define __lsx_vslei_d(/*__m128i*/ _1, /*si5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsle_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsle_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V16QI, UV16QI, UQI. */ ++#define __lsx_vslei_bu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_bu ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, UV8HI, UQI. */ ++#define __lsx_vslei_hu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_hu ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, UV4SI, UQI. */ ++#define __lsx_vslei_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_wu ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V2DI, UV2DI, UQI. */ ++#define __lsx_vslei_du(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vslei_du ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vsat_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vsat_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vsat_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vsat_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vsat_bu(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_bu ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UQI. */ ++#define __lsx_vsat_hu(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_hu ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UQI. */ ++#define __lsx_vsat_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_wu ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UQI. */ ++#define __lsx_vsat_du(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vsat_du ((v2u64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadda_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadda_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadda_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadda_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadda_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadda_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadda_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadda_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsadd_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsadd_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavg_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavg_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vavgr_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vavgr_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssub_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssub_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vabsd_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vabsd_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmul_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmul_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmul_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmul_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmul_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmul_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmul_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmul_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmadd_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmadd_b ((v16i8)_1, (v16i8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmadd_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmadd_h ((v8i16)_1, (v8i16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmadd_w (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmadd_w ((v4i32)_1, (v4i32)_2, (v4i32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmadd_d (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmadd_d ((v2i64)_1, (v2i64)_2, (v2i64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmsub_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmsub_b ((v16i8)_1, (v16i8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmsub_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmsub_h ((v8i16)_1, (v8i16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmsub_w (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmsub_w ((v4i32)_1, (v4i32)_2, (v4i32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmsub_d (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmsub_d ((v2i64)_1, (v2i64)_2, (v2i64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vdiv_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vdiv_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_hu_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_hu_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_wu_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_wu_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_du_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_du_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_hu_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_hu_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_wu_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_wu_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_du_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_du_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmod_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmod_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, rk. */ ++/* Data types in instruction templates: V16QI, V16QI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplve_b (__m128i _1, int _2) ++{ ++ return (__m128i)__builtin_lsx_vreplve_b ((v16i8)_1, (int)_2); ++} ++ ++/* Assembly instruction format: vd, vj, rk. */ ++/* Data types in instruction templates: V8HI, V8HI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplve_h (__m128i _1, int _2) ++{ ++ return (__m128i)__builtin_lsx_vreplve_h ((v8i16)_1, (int)_2); ++} ++ ++/* Assembly instruction format: vd, vj, rk. */ ++/* Data types in instruction templates: V4SI, V4SI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplve_w (__m128i _1, int _2) ++{ ++ return (__m128i)__builtin_lsx_vreplve_w ((v4i32)_1, (int)_2); ++} ++ ++/* Assembly instruction format: vd, vj, rk. */ ++/* Data types in instruction templates: V2DI, V2DI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplve_d (__m128i _1, int _2) ++{ ++ return (__m128i)__builtin_lsx_vreplve_d ((v2i64)_1, (int)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vreplvei_b(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vreplvei_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vreplvei_h(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vreplvei_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui2. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vreplvei_w(/*__m128i*/ _1, /*ui2*/ _2) \ ++ ((__m128i)__builtin_lsx_vreplvei_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui1. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vreplvei_d(/*__m128i*/ _1, /*ui1*/ _2) \ ++ ((__m128i)__builtin_lsx_vreplvei_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickev_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickev_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickev_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickev_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickev_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickev_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickev_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickev_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickod_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickod_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickod_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickod_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickod_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickod_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpickod_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpickod_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvh_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvh_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvh_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvh_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvh_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvh_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvh_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvh_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvl_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvl_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvl_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvl_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvl_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvl_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vilvl_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vilvl_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackev_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackev_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackev_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackev_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackev_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackev_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackev_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackev_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackod_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackod_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackod_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackod_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackod_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackod_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpackod_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vpackod_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vshuf_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vshuf_h ((v8i16)_1, (v8i16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vshuf_w (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vshuf_w ((v4i32)_1, (v4i32)_2, (v4i32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vshuf_d (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vshuf_d ((v2i64)_1, (v2i64)_2, (v2i64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vand_v (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vand_v ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vandi_b(/*__m128i*/ _1, /*ui8*/ _2) \ ++ ((__m128i)__builtin_lsx_vandi_b ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vor_v (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vor_v ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vori_b(/*__m128i*/ _1, /*ui8*/ _2) \ ++ ((__m128i)__builtin_lsx_vori_b ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vnor_v (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vnor_v ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vnori_b(/*__m128i*/ _1, /*ui8*/ _2) \ ++ ((__m128i)__builtin_lsx_vnori_b ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vxor_v (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vxor_v ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UQI. */ ++#define __lsx_vxori_b(/*__m128i*/ _1, /*ui8*/ _2) \ ++ ((__m128i)__builtin_lsx_vxori_b ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vbitsel_v (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vbitsel_v ((v16u8)_1, (v16u8)_2, (v16u8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI, USI. */ ++#define __lsx_vbitseli_b(/*__m128i*/ _1, /*__m128i*/ _2, /*ui8*/ _3) \ ++ ((__m128i)__builtin_lsx_vbitseli_b ((v16u8)(_1), (v16u8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V16QI, V16QI, USI. */ ++#define __lsx_vshuf4i_b(/*__m128i*/ _1, /*ui8*/ _2) \ ++ ((__m128i)__builtin_lsx_vshuf4i_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V8HI, V8HI, USI. */ ++#define __lsx_vshuf4i_h(/*__m128i*/ _1, /*ui8*/ _2) \ ++ ((__m128i)__builtin_lsx_vshuf4i_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V4SI, V4SI, USI. */ ++#define __lsx_vshuf4i_w(/*__m128i*/ _1, /*ui8*/ _2) \ ++ ((__m128i)__builtin_lsx_vshuf4i_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, rj. */ ++/* Data types in instruction templates: V16QI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplgr2vr_b (int _1) ++{ ++ return (__m128i)__builtin_lsx_vreplgr2vr_b ((int)_1); ++} ++ ++/* Assembly instruction format: vd, rj. */ ++/* Data types in instruction templates: V8HI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplgr2vr_h (int _1) ++{ ++ return (__m128i)__builtin_lsx_vreplgr2vr_h ((int)_1); ++} ++ ++/* Assembly instruction format: vd, rj. */ ++/* Data types in instruction templates: V4SI, SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplgr2vr_w (int _1) ++{ ++ return (__m128i)__builtin_lsx_vreplgr2vr_w ((int)_1); ++} ++ ++/* Assembly instruction format: vd, rj. */ ++/* Data types in instruction templates: V2DI, DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vreplgr2vr_d (long int _1) ++{ ++ return (__m128i)__builtin_lsx_vreplgr2vr_d ((long int)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpcnt_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vpcnt_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpcnt_h (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vpcnt_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpcnt_w (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vpcnt_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vpcnt_d (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vpcnt_d ((v2i64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclo_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclo_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclo_h (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclo_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclo_w (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclo_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclo_d (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclo_d ((v2i64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclz_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclz_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclz_h (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclz_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclz_w (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclz_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vclz_d (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vclz_d ((v2i64)_1); ++} ++ ++/* Assembly instruction format: rd, vj, ui4. */ ++/* Data types in instruction templates: SI, V16QI, UQI. */ ++#define __lsx_vpickve2gr_b(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((int)__builtin_lsx_vpickve2gr_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: rd, vj, ui3. */ ++/* Data types in instruction templates: SI, V8HI, UQI. */ ++#define __lsx_vpickve2gr_h(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((int)__builtin_lsx_vpickve2gr_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: rd, vj, ui2. */ ++/* Data types in instruction templates: SI, V4SI, UQI. */ ++#define __lsx_vpickve2gr_w(/*__m128i*/ _1, /*ui2*/ _2) \ ++ ((int)__builtin_lsx_vpickve2gr_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: rd, vj, ui1. */ ++/* Data types in instruction templates: DI, V2DI, UQI. */ ++#define __lsx_vpickve2gr_d(/*__m128i*/ _1, /*ui1*/ _2) \ ++ ((long int)__builtin_lsx_vpickve2gr_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: rd, vj, ui4. */ ++/* Data types in instruction templates: USI, V16QI, UQI. */ ++#define __lsx_vpickve2gr_bu(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((unsigned int)__builtin_lsx_vpickve2gr_bu ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: rd, vj, ui3. */ ++/* Data types in instruction templates: USI, V8HI, UQI. */ ++#define __lsx_vpickve2gr_hu(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((unsigned int)__builtin_lsx_vpickve2gr_hu ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: rd, vj, ui2. */ ++/* Data types in instruction templates: USI, V4SI, UQI. */ ++#define __lsx_vpickve2gr_wu(/*__m128i*/ _1, /*ui2*/ _2) \ ++ ((unsigned int)__builtin_lsx_vpickve2gr_wu ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: rd, vj, ui1. */ ++/* Data types in instruction templates: UDI, V2DI, UQI. */ ++#define __lsx_vpickve2gr_du(/*__m128i*/ _1, /*ui1*/ _2) \ ++ ((unsigned long int)__builtin_lsx_vpickve2gr_du ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, rj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, SI, UQI. */ ++#define __lsx_vinsgr2vr_b(/*__m128i*/ _1, /*int*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vinsgr2vr_b ((v16i8)(_1), (int)(_2), (_3))) ++ ++/* Assembly instruction format: vd, rj, ui3. */ ++/* Data types in instruction templates: V8HI, V8HI, SI, UQI. */ ++#define __lsx_vinsgr2vr_h(/*__m128i*/ _1, /*int*/ _2, /*ui3*/ _3) \ ++ ((__m128i)__builtin_lsx_vinsgr2vr_h ((v8i16)(_1), (int)(_2), (_3))) ++ ++/* Assembly instruction format: vd, rj, ui2. */ ++/* Data types in instruction templates: V4SI, V4SI, SI, UQI. */ ++#define __lsx_vinsgr2vr_w(/*__m128i*/ _1, /*int*/ _2, /*ui2*/ _3) \ ++ ((__m128i)__builtin_lsx_vinsgr2vr_w ((v4i32)(_1), (int)(_2), (_3))) ++ ++/* Assembly instruction format: vd, rj, ui1. */ ++/* Data types in instruction templates: V2DI, V2DI, DI, UQI. */ ++#define __lsx_vinsgr2vr_d(/*__m128i*/ _1, /*long int*/ _2, /*ui1*/ _3) \ ++ ((__m128i)__builtin_lsx_vinsgr2vr_d ((v2i64)(_1), (long int)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfadd_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfadd_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfadd_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfadd_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfsub_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfsub_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfsub_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfsub_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfmul_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfmul_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfmul_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfmul_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfdiv_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfdiv_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfdiv_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfdiv_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcvt_h_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcvt_h_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfcvt_s_d (__m128d _1, __m128d _2) ++{ ++ return (__m128)__builtin_lsx_vfcvt_s_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfmin_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfmin_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfmin_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfmin_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfmina_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfmina_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfmina_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfmina_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfmax_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfmax_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfmax_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfmax_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfmaxa_s (__m128 _1, __m128 _2) ++{ ++ return (__m128)__builtin_lsx_vfmaxa_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfmaxa_d (__m128d _1, __m128d _2) ++{ ++ return (__m128d)__builtin_lsx_vfmaxa_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfclass_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vfclass_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfclass_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vfclass_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfsqrt_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfsqrt_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfsqrt_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfsqrt_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfrecip_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfrecip_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfrecip_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfrecip_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfrint_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfrint_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfrint_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfrint_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfrsqrt_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfrsqrt_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfrsqrt_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfrsqrt_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vflogb_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vflogb_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vflogb_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vflogb_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfcvth_s_h (__m128i _1) ++{ ++ return (__m128)__builtin_lsx_vfcvth_s_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfcvth_d_s (__m128 _1) ++{ ++ return (__m128d)__builtin_lsx_vfcvth_d_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfcvtl_s_h (__m128i _1) ++{ ++ return (__m128)__builtin_lsx_vfcvtl_s_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfcvtl_d_s (__m128 _1) ++{ ++ return (__m128d)__builtin_lsx_vfcvtl_d_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftint_w_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftint_w_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftint_l_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vftint_l_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftint_wu_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftint_wu_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftint_lu_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vftint_lu_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrz_w_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrz_w_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrz_l_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrz_l_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrz_wu_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrz_wu_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrz_lu_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrz_lu_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vffint_s_w (__m128i _1) ++{ ++ return (__m128)__builtin_lsx_vffint_s_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vffint_d_l (__m128i _1) ++{ ++ return (__m128d)__builtin_lsx_vffint_d_l ((v2i64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SF, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vffint_s_wu (__m128i _1) ++{ ++ return (__m128)__builtin_lsx_vffint_s_wu ((v4u32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vffint_d_lu (__m128i _1) ++{ ++ return (__m128d)__builtin_lsx_vffint_d_lu ((v2u64)_1); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vandn_v (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vandn_v ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vneg_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vneg_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vneg_h (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vneg_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vneg_w (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vneg_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vneg_d (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vneg_d ((v2i64)_1); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmuh_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmuh_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V8HI, V16QI, UQI. */ ++#define __lsx_vsllwil_h_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsllwil_h_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V4SI, V8HI, UQI. */ ++#define __lsx_vsllwil_w_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsllwil_w_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V2DI, V4SI, UQI. */ ++#define __lsx_vsllwil_d_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsllwil_d_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: UV8HI, UV16QI, UQI. */ ++#define __lsx_vsllwil_hu_bu(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vsllwil_hu_bu ((v16u8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV4SI, UV8HI, UQI. */ ++#define __lsx_vsllwil_wu_hu(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vsllwil_wu_hu ((v8u16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV2DI, UV4SI, UQI. */ ++#define __lsx_vsllwil_du_wu(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vsllwil_du_wu ((v4u32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsran_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsran_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsran_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsran_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsran_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsran_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssran_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssran_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssran_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssran_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssran_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssran_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssran_bu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssran_bu_h ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssran_hu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssran_hu_w ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssran_wu_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssran_wu_d ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrarn_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrarn_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrarn_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrarn_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrarn_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrarn_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrarn_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrarn_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrarn_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrarn_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrarn_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrarn_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrarn_bu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrarn_bu_h ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrarn_hu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrarn_hu_w ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrarn_wu_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrarn_wu_d ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrln_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrln_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrln_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrln_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrln_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrln_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrln_bu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrln_bu_h ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrln_hu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrln_hu_w ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrln_wu_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrln_wu_d ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrlrn_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrlrn_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrlrn_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrlrn_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsrlrn_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsrlrn_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV16QI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrlrn_bu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrlrn_bu_h ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrlrn_hu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrlrn_hu_w ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrlrn_wu_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrlrn_wu_d ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, UQI. */ ++#define __lsx_vfrstpi_b(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vfrstpi_b ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, UQI. */ ++#define __lsx_vfrstpi_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vfrstpi_h ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfrstp_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vfrstp_b ((v16i8)_1, (v16i8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfrstp_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vfrstp_h ((v8i16)_1, (v8i16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vshuf4i_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui8*/ _3) \ ++ ((__m128i)__builtin_lsx_vshuf4i_d ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vbsrl_v(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vbsrl_v ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vbsll_v(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vbsll_v ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vextrins_b(/*__m128i*/ _1, /*__m128i*/ _2, /*ui8*/ _3) \ ++ ((__m128i)__builtin_lsx_vextrins_b ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vextrins_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui8*/ _3) \ ++ ((__m128i)__builtin_lsx_vextrins_h ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vextrins_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui8*/ _3) \ ++ ((__m128i)__builtin_lsx_vextrins_w ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vextrins_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui8*/ _3) \ ++ ((__m128i)__builtin_lsx_vextrins_d ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmskltz_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vmskltz_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmskltz_h (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vmskltz_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmskltz_w (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vmskltz_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmskltz_d (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vmskltz_d ((v2i64)_1); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsigncov_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsigncov_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsigncov_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsigncov_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsigncov_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsigncov_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsigncov_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsigncov_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfmadd_s (__m128 _1, __m128 _2, __m128 _3) ++{ ++ return (__m128)__builtin_lsx_vfmadd_s ((v4f32)_1, (v4f32)_2, (v4f32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfmadd_d (__m128d _1, __m128d _2, __m128d _3) ++{ ++ return (__m128d)__builtin_lsx_vfmadd_d ((v2f64)_1, (v2f64)_2, (v2f64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfmsub_s (__m128 _1, __m128 _2, __m128 _3) ++{ ++ return (__m128)__builtin_lsx_vfmsub_s ((v4f32)_1, (v4f32)_2, (v4f32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfmsub_d (__m128d _1, __m128d _2, __m128d _3) ++{ ++ return (__m128d)__builtin_lsx_vfmsub_d ((v2f64)_1, (v2f64)_2, (v2f64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfnmadd_s (__m128 _1, __m128 _2, __m128 _3) ++{ ++ return (__m128)__builtin_lsx_vfnmadd_s ((v4f32)_1, (v4f32)_2, (v4f32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfnmadd_d (__m128d _1, __m128d _2, __m128d _3) ++{ ++ return (__m128d)__builtin_lsx_vfnmadd_d ((v2f64)_1, (v2f64)_2, (v2f64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V4SF, V4SF, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfnmsub_s (__m128 _1, __m128 _2, __m128 _3) ++{ ++ return (__m128)__builtin_lsx_vfnmsub_s ((v4f32)_1, (v4f32)_2, (v4f32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V2DF, V2DF, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfnmsub_d (__m128d _1, __m128d _2, __m128d _3) ++{ ++ return (__m128d)__builtin_lsx_vfnmsub_d ((v2f64)_1, (v2f64)_2, (v2f64)_3); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrne_w_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrne_w_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrne_l_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrne_l_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrp_w_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrp_w_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrp_l_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrp_l_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrm_w_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrm_w_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrm_l_d (__m128d _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrm_l_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftint_w_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vftint_w_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SF, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vffint_s_l (__m128i _1, __m128i _2) ++{ ++ return (__m128)__builtin_lsx_vffint_s_l ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrz_w_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vftintrz_w_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrp_w_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vftintrp_w_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrm_w_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vftintrm_w_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrne_w_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vftintrne_w_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintl_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintl_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftinth_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftinth_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vffinth_d_w (__m128i _1) ++{ ++ return (__m128d)__builtin_lsx_vffinth_d_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DF, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vffintl_d_w (__m128i _1) ++{ ++ return (__m128d)__builtin_lsx_vffintl_d_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrzl_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrzl_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrzh_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrzh_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrpl_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrpl_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrph_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrph_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrml_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrml_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrmh_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrmh_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrnel_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrnel_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vftintrneh_l_s (__m128 _1) ++{ ++ return (__m128i)__builtin_lsx_vftintrneh_l_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfrintrne_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfrintrne_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfrintrne_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfrintrne_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfrintrz_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfrintrz_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfrintrz_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfrintrz_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfrintrp_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfrintrp_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfrintrp_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfrintrp_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128 __lsx_vfrintrm_s (__m128 _1) ++{ ++ return (__m128)__builtin_lsx_vfrintrm_s ((v4f32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128d __lsx_vfrintrm_d (__m128d _1) ++{ ++ return (__m128d)__builtin_lsx_vfrintrm_d ((v2f64)_1); ++} ++ ++/* Assembly instruction format: vd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V16QI, CVPOINTER, SI, UQI. */ ++#define __lsx_vstelm_b(/*__m128i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lsx_vstelm_b ((v16i8)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: vd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V8HI, CVPOINTER, SI, UQI. */ ++#define __lsx_vstelm_h(/*__m128i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lsx_vstelm_h ((v8i16)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: vd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V4SI, CVPOINTER, SI, UQI. */ ++#define __lsx_vstelm_w(/*__m128i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lsx_vstelm_w ((v4i32)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: vd, rj, si8, idx. */ ++/* Data types in instruction templates: VOID, V2DI, CVPOINTER, SI, UQI. */ ++#define __lsx_vstelm_d(/*__m128i*/ _1, /*void **/ _2, /*si8*/ _3, /*idx*/ _4) \ ++ ((void)__builtin_lsx_vstelm_d ((v2i64)(_1), (void *)(_2), (_3), (_4))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_d_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_d_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_w_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_w_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_h_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_h_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_d_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_d_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_w_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_w_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_h_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_h_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_d_wu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_d_wu_w ((v4u32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_w_hu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_w_hu_h ((v8u16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_h_bu_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_h_bu_b ((v16u8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_d_wu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_d_wu_w ((v4u32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_w_hu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_w_hu_h ((v8u16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_h_bu_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_h_bu_b ((v16u8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_d_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_d_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_w_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_w_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_h_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_h_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_d_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_d_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_w_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_w_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_h_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_h_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_q_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_q_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_q_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_q_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwev_q_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwev_q_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsubwod_q_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsubwod_q_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwev_q_du_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwev_q_du_d ((v2u64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vaddwod_q_du_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vaddwod_q_du_d ((v2u64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_d_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_d_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_w_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_w_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_h_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_h_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_d_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_d_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_w_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_w_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_h_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_h_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_d_wu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_d_wu ((v4u32)_1, (v4u32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_w_hu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_w_hu ((v8u16)_1, (v8u16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_h_bu (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_h_bu ((v16u8)_1, (v16u8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_d_wu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_d_wu_w ((v4u32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_w_hu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_w_hu_h ((v8u16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_h_bu_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_h_bu_b ((v16u8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_d_wu_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_d_wu_w ((v4u32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, UV8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_w_hu_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_w_hu_h ((v8u16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, UV16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_h_bu_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_h_bu_b ((v16u8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_q_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_q_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_q_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_q_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwev_q_du_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwev_q_du_d ((v2u64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, UV2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmulwod_q_du_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vmulwod_q_du_d ((v2u64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhaddw_qu_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhaddw_qu_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_q_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_q_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vhsubw_qu_du (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vhsubw_qu_du ((v2u64)_1, (v2u64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_d_w (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_d_w ((v2i64)_1, (v4i32)_2, (v4i32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_w_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_w_h ((v4i32)_1, (v8i16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_h_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_h_b ((v8i16)_1, (v16i8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_d_wu (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_d_wu ((v2u64)_1, (v4u32)_2, (v4u32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_w_hu (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_w_hu ((v4u32)_1, (v8u16)_2, (v8u16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_h_bu (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_h_bu ((v8u16)_1, (v16u8)_2, (v16u8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_d_w (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_d_w ((v2i64)_1, (v4i32)_2, (v4i32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_w_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_w_h ((v4i32)_1, (v8i16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_h_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_h_b ((v8i16)_1, (v16i8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV4SI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_d_wu (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_d_wu ((v2u64)_1, (v4u32)_2, (v4u32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV4SI, UV4SI, UV8HI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_w_hu (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_w_hu ((v4u32)_1, (v8u16)_2, (v8u16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV8HI, UV8HI, UV16QI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_h_bu (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_h_bu ((v8u16)_1, (v16u8)_2, (v16u8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, UV4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_d_wu_w (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_d_wu_w ((v2i64)_1, (v4u32)_2, (v4i32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, UV8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_w_hu_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_w_hu_h ((v4i32)_1, (v8u16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, UV16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_h_bu_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_h_bu_b ((v8i16)_1, (v16u8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, UV4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_d_wu_w (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_d_wu_w ((v2i64)_1, (v4u32)_2, (v4i32)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, UV8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_w_hu_h (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_w_hu_h ((v4i32)_1, (v8u16)_2, (v8i16)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, UV16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_h_bu_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_h_bu_b ((v8i16)_1, (v16u8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_q_d (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_q_d ((v2i64)_1, (v2i64)_2, (v2i64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_q_d (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_q_d ((v2i64)_1, (v2i64)_2, (v2i64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_q_du (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_q_du ((v2u64)_1, (v2u64)_2, (v2u64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: UV2DI, UV2DI, UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_q_du (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_q_du ((v2u64)_1, (v2u64)_2, (v2u64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, UV2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwev_q_du_d (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwev_q_du_d ((v2i64)_1, (v2u64)_2, (v2i64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, UV2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmaddwod_q_du_d (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vmaddwod_q_du_d ((v2i64)_1, (v2u64)_2, (v2i64)_3); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vrotr_b (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vrotr_b ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vrotr_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vrotr_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vrotr_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vrotr_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vrotr_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vrotr_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vadd_q (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vadd_q ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vsub_q (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vsub_q ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, rj, si12. */ ++/* Data types in instruction templates: V16QI, CVPOINTER, SI. */ ++#define __lsx_vldrepl_b(/*void **/ _1, /*si12*/ _2) \ ++ ((__m128i)__builtin_lsx_vldrepl_b ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: vd, rj, si11. */ ++/* Data types in instruction templates: V8HI, CVPOINTER, SI. */ ++#define __lsx_vldrepl_h(/*void **/ _1, /*si11*/ _2) \ ++ ((__m128i)__builtin_lsx_vldrepl_h ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: vd, rj, si10. */ ++/* Data types in instruction templates: V4SI, CVPOINTER, SI. */ ++#define __lsx_vldrepl_w(/*void **/ _1, /*si10*/ _2) \ ++ ((__m128i)__builtin_lsx_vldrepl_w ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: vd, rj, si9. */ ++/* Data types in instruction templates: V2DI, CVPOINTER, SI. */ ++#define __lsx_vldrepl_d(/*void **/ _1, /*si9*/ _2) \ ++ ((__m128i)__builtin_lsx_vldrepl_d ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmskgez_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vmskgez_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vmsknz_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vmsknz_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V8HI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_h_b (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_h_b ((v16i8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V4SI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_w_h (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_w_h ((v8i16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_d_w (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_d_w ((v4i32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_q_d (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_q_d ((v2i64)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV8HI, UV16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_hu_bu (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_hu_bu ((v16u8)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV4SI, UV8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_wu_hu (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_wu_hu ((v8u16)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV2DI, UV4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_du_wu (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_du_wu ((v4u32)_1); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vexth_qu_du (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vexth_qu_du ((v2u64)_1); ++} ++ ++/* Assembly instruction format: vd, vj, ui3. */ ++/* Data types in instruction templates: V16QI, V16QI, UQI. */ ++#define __lsx_vrotri_b(/*__m128i*/ _1, /*ui3*/ _2) \ ++ ((__m128i)__builtin_lsx_vrotri_b ((v16i8)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V8HI, V8HI, UQI. */ ++#define __lsx_vrotri_h(/*__m128i*/ _1, /*ui4*/ _2) \ ++ ((__m128i)__builtin_lsx_vrotri_h ((v8i16)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V4SI, V4SI, UQI. */ ++#define __lsx_vrotri_w(/*__m128i*/ _1, /*ui5*/ _2) \ ++ ((__m128i)__builtin_lsx_vrotri_w ((v4i32)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V2DI, V2DI, UQI. */ ++#define __lsx_vrotri_d(/*__m128i*/ _1, /*ui6*/ _2) \ ++ ((__m128i)__builtin_lsx_vrotri_d ((v2i64)(_1), (_2))) ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vextl_q_d (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vextl_q_d ((v2i64)_1); ++} ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vsrlni_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlni_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vsrlni_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlni_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vsrlni_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlni_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vsrlni_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlni_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vsrlrni_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlrni_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vsrlrni_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlrni_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vsrlrni_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlrni_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vsrlrni_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrlrni_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vssrlni_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vssrlni_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vssrlni_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vssrlni_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV16QI, UV16QI, V16QI, USI. */ ++#define __lsx_vssrlni_bu_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_bu_h ((v16u8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV8HI, UV8HI, V8HI, USI. */ ++#define __lsx_vssrlni_hu_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_hu_w ((v8u16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV4SI, UV4SI, V4SI, USI. */ ++#define __lsx_vssrlni_wu_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_wu_d ((v4u32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: UV2DI, UV2DI, V2DI, USI. */ ++#define __lsx_vssrlni_du_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlni_du_q ((v2u64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vssrlrni_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vssrlrni_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vssrlrni_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vssrlrni_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV16QI, UV16QI, V16QI, USI. */ ++#define __lsx_vssrlrni_bu_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_bu_h ((v16u8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV8HI, UV8HI, V8HI, USI. */ ++#define __lsx_vssrlrni_hu_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_hu_w ((v8u16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV4SI, UV4SI, V4SI, USI. */ ++#define __lsx_vssrlrni_wu_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_wu_d ((v4u32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: UV2DI, UV2DI, V2DI, USI. */ ++#define __lsx_vssrlrni_du_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrlrni_du_q ((v2u64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vsrani_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrani_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vsrani_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrani_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vsrani_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrani_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vsrani_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrani_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vsrarni_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrarni_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vsrarni_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrarni_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vsrarni_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrarni_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vsrarni_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vsrarni_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vssrani_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vssrani_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vssrani_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vssrani_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV16QI, UV16QI, V16QI, USI. */ ++#define __lsx_vssrani_bu_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_bu_h ((v16u8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV8HI, UV8HI, V8HI, USI. */ ++#define __lsx_vssrani_hu_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_hu_w ((v8u16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV4SI, UV4SI, V4SI, USI. */ ++#define __lsx_vssrani_wu_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_wu_d ((v4u32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: UV2DI, UV2DI, V2DI, USI. */ ++#define __lsx_vssrani_du_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrani_du_q ((v2u64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, USI. */ ++#define __lsx_vssrarni_b_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_b_h ((v16i8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: V8HI, V8HI, V8HI, USI. */ ++#define __lsx_vssrarni_h_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_h_w ((v8i16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vssrarni_w_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_w_d ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: V2DI, V2DI, V2DI, USI. */ ++#define __lsx_vssrarni_d_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_d_q ((v2i64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui4. */ ++/* Data types in instruction templates: UV16QI, UV16QI, V16QI, USI. */ ++#define __lsx_vssrarni_bu_h(/*__m128i*/ _1, /*__m128i*/ _2, /*ui4*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_bu_h ((v16u8)(_1), (v16i8)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui5. */ ++/* Data types in instruction templates: UV8HI, UV8HI, V8HI, USI. */ ++#define __lsx_vssrarni_hu_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui5*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_hu_w ((v8u16)(_1), (v8i16)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui6. */ ++/* Data types in instruction templates: UV4SI, UV4SI, V4SI, USI. */ ++#define __lsx_vssrarni_wu_d(/*__m128i*/ _1, /*__m128i*/ _2, /*ui6*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_wu_d ((v4u32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui7. */ ++/* Data types in instruction templates: UV2DI, UV2DI, V2DI, USI. */ ++#define __lsx_vssrarni_du_q(/*__m128i*/ _1, /*__m128i*/ _2, /*ui7*/ _3) \ ++ ((__m128i)__builtin_lsx_vssrarni_du_q ((v2u64)(_1), (v2i64)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, ui8. */ ++/* Data types in instruction templates: V4SI, V4SI, V4SI, USI. */ ++#define __lsx_vpermi_w(/*__m128i*/ _1, /*__m128i*/ _2, /*ui8*/ _3) \ ++ ((__m128i)__builtin_lsx_vpermi_w ((v4i32)(_1), (v4i32)(_2), (_3))) ++ ++/* Assembly instruction format: vd, rj, si12. */ ++/* Data types in instruction templates: V16QI, CVPOINTER, SI. */ ++#define __lsx_vld(/*void **/ _1, /*si12*/ _2) \ ++ ((__m128i)__builtin_lsx_vld ((void *)(_1), (_2))) ++ ++/* Assembly instruction format: vd, rj, si12. */ ++/* Data types in instruction templates: VOID, V16QI, CVPOINTER, SI. */ ++#define __lsx_vst(/*__m128i*/ _1, /*void **/ _2, /*si12*/ _3) \ ++ ((void)__builtin_lsx_vst ((v16i8)(_1), (void *)(_2), (_3))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrlrn_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrlrn_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrlrn_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrlrn_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrlrn_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrlrn_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V8HI, V8HI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrln_b_h (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrln_b_h ((v8i16)_1, (v8i16)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V8HI, V4SI, V4SI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrln_h_w (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrln_h_w ((v4i32)_1, (v4i32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V2DI, V2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vssrln_w_d (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vssrln_w_d ((v2i64)_1, (v2i64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vorn_v (__m128i _1, __m128i _2) ++{ ++ return (__m128i)__builtin_lsx_vorn_v ((v16i8)_1, (v16i8)_2); ++} ++ ++/* Assembly instruction format: vd, i13. */ ++/* Data types in instruction templates: V2DI, HI. */ ++#define __lsx_vldi(/*i13*/ _1) \ ++ ((__m128i)__builtin_lsx_vldi ((_1))) ++ ++/* Assembly instruction format: vd, vj, vk, va. */ ++/* Data types in instruction templates: V16QI, V16QI, V16QI, V16QI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vshuf_b (__m128i _1, __m128i _2, __m128i _3) ++{ ++ return (__m128i)__builtin_lsx_vshuf_b ((v16i8)_1, (v16i8)_2, (v16i8)_3); ++} ++ ++/* Assembly instruction format: vd, rj, rk. */ ++/* Data types in instruction templates: V16QI, CVPOINTER, DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vldx (void * _1, long int _2) ++{ ++ return (__m128i)__builtin_lsx_vldx ((void *)_1, (long int)_2); ++} ++ ++/* Assembly instruction format: vd, rj, rk. */ ++/* Data types in instruction templates: VOID, V16QI, CVPOINTER, DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++void __lsx_vstx (__m128i _1, void * _2, long int _3) ++{ ++ return (void)__builtin_lsx_vstx ((v16i8)_1, (void *)_2, (long int)_3); ++} ++ ++/* Assembly instruction format: vd, vj. */ ++/* Data types in instruction templates: UV2DI, UV2DI. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vextl_qu_du (__m128i _1) ++{ ++ return (__m128i)__builtin_lsx_vextl_qu_du ((v2u64)_1); ++} ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV16QI. */ ++#define __lsx_bnz_b(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bnz_b ((v16u8)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV2DI. */ ++#define __lsx_bnz_d(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bnz_d ((v2u64)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV8HI. */ ++#define __lsx_bnz_h(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bnz_h ((v8u16)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV16QI. */ ++#define __lsx_bnz_v(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bnz_v ((v16u8)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV4SI. */ ++#define __lsx_bnz_w(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bnz_w ((v4u32)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV16QI. */ ++#define __lsx_bz_b(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bz_b ((v16u8)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV2DI. */ ++#define __lsx_bz_d(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bz_d ((v2u64)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV8HI. */ ++#define __lsx_bz_h(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bz_h ((v8u16)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV16QI. */ ++#define __lsx_bz_v(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bz_v ((v16u8)(_1))) ++ ++/* Assembly instruction format: cd, vj. */ ++/* Data types in instruction templates: SI, UV4SI. */ ++#define __lsx_bz_w(/*__m128i*/ _1) \ ++ ((int)__builtin_lsx_bz_w ((v4u32)(_1))) ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_caf_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_caf_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_caf_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_caf_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_ceq_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_ceq_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_ceq_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_ceq_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cle_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cle_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cle_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cle_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_clt_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_clt_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_clt_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_clt_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cne_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cne_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cne_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cne_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cor_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cor_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cor_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cor_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cueq_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cueq_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cueq_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cueq_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cule_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cule_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cule_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cule_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cult_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cult_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cult_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cult_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cun_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cun_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cune_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cune_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cune_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cune_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_cun_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_cun_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_saf_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_saf_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_saf_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_saf_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_seq_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_seq_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_seq_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_seq_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sle_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sle_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sle_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sle_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_slt_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_slt_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_slt_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_slt_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sne_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sne_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sne_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sne_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sor_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sor_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sor_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sor_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sueq_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sueq_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sueq_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sueq_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sule_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sule_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sule_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sule_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sult_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sult_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sult_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sult_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sun_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sun_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V2DI, V2DF, V2DF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sune_d (__m128d _1, __m128d _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sune_d ((v2f64)_1, (v2f64)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sune_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sune_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, vj, vk. */ ++/* Data types in instruction templates: V4SI, V4SF, V4SF. */ ++extern __inline __attribute__((__gnu_inline__, __always_inline__, __artificial__)) ++__m128i __lsx_vfcmp_sun_s (__m128 _1, __m128 _2) ++{ ++ return (__m128i)__builtin_lsx_vfcmp_sun_s ((v4f32)_1, (v4f32)_2); ++} ++ ++/* Assembly instruction format: vd, si10. */ ++/* Data types in instruction templates: V16QI, HI. */ ++#define __lsx_vrepli_b(/*si10*/ _1) \ ++ ((__m128i)__builtin_lsx_vrepli_b ((_1))) ++ ++/* Assembly instruction format: vd, si10. */ ++/* Data types in instruction templates: V2DI, HI. */ ++#define __lsx_vrepli_d(/*si10*/ _1) \ ++ ((__m128i)__builtin_lsx_vrepli_d ((_1))) ++ ++/* Assembly instruction format: vd, si10. */ ++/* Data types in instruction templates: V8HI, HI. */ ++#define __lsx_vrepli_h(/*si10*/ _1) \ ++ ((__m128i)__builtin_lsx_vrepli_h ((_1))) ++ ++/* Assembly instruction format: vd, si10. */ ++/* Data types in instruction templates: V4SI, HI. */ ++#define __lsx_vrepli_w(/*si10*/ _1) \ ++ ((__m128i)__builtin_lsx_vrepli_w ((_1))) ++ ++#endif /* defined(__loongarch_sx) */ ++#endif /* _GCC_LOONGSON_SXINTRIN_H */ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-built-in-functions-description-of-Loon.patch
Added
@@ -0,0 +1,166 @@ +From 7cfe6e057045ac794afbe9097b1b211c0e1ea723 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 6 Apr 2023 16:02:07 +0800 +Subject: PATCH 039/124 LoongArch: Add built-in functions description of + LoongArch Base instruction set instructions. + +gcc/ChangeLog: + + * doc/extend.texi: Add section for LoongArch Base Built-in functions. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/doc/extend.texi | 129 ++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 129 insertions(+) + +diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi +index 3c101ca89..1d1bac255 100644 +--- a/gcc/doc/extend.texi ++++ b/gcc/doc/extend.texi +@@ -14678,6 +14678,7 @@ instructions, but allow the compiler to schedule those calls. + * Blackfin Built-in Functions:: + * BPF Built-in Functions:: + * FR-V Built-in Functions:: ++* LoongArch Base Built-in Functions:: + * MIPS DSP Built-in Functions:: + * MIPS Paired-Single Support:: + * MIPS Loongson Built-in Functions:: +@@ -16128,6 +16129,134 @@ Use the @code{nldub} instruction to load the contents of address @var{x} + into the data cache. The instruction is issued in slot I1@. + @end table + ++@node LoongArch Base Built-in Functions ++@subsection LoongArch Base Built-in Functions ++ ++These built-in functions are available for LoongArch. ++ ++Data Type Description: ++@itemize ++@item @code{imm0_31}, a compile-time constant in range 0 to 31; ++@item @code{imm0_16383}, a compile-time constant in range 0 to 16383; ++@item @code{imm0_32767}, a compile-time constant in range 0 to 32767; ++@item @code{imm_n2048_2047}, a compile-time constant in range -2048 to 2047; ++@end itemize ++ ++The intrinsics provided are listed below: ++@smallexample ++ unsigned int __builtin_loongarch_movfcsr2gr (imm0_31) ++ void __builtin_loongarch_movgr2fcsr (imm0_31, unsigned int) ++ void __builtin_loongarch_cacop_d (imm0_31, unsigned long int, imm_n2048_2047) ++ unsigned int __builtin_loongarch_cpucfg (unsigned int) ++ void __builtin_loongarch_asrtle_d (long int, long int) ++ void __builtin_loongarch_asrtgt_d (long int, long int) ++ long int __builtin_loongarch_lddir_d (long int, imm0_31) ++ void __builtin_loongarch_ldpte_d (long int, imm0_31) ++ ++ int __builtin_loongarch_crc_w_b_w (char, int) ++ int __builtin_loongarch_crc_w_h_w (short, int) ++ int __builtin_loongarch_crc_w_w_w (int, int) ++ int __builtin_loongarch_crc_w_d_w (long int, int) ++ int __builtin_loongarch_crcc_w_b_w (char, int) ++ int __builtin_loongarch_crcc_w_h_w (short, int) ++ int __builtin_loongarch_crcc_w_w_w (int, int) ++ int __builtin_loongarch_crcc_w_d_w (long int, int) ++ ++ unsigned int __builtin_loongarch_csrrd_w (imm0_16383) ++ unsigned int __builtin_loongarch_csrwr_w (unsigned int, imm0_16383) ++ unsigned int __builtin_loongarch_csrxchg_w (unsigned int, unsigned int, imm0_16383) ++ unsigned long int __builtin_loongarch_csrrd_d (imm0_16383) ++ unsigned long int __builtin_loongarch_csrwr_d (unsigned long int, imm0_16383) ++ unsigned long int __builtin_loongarch_csrxchg_d (unsigned long int, unsigned long int, imm0_16383) ++ ++ unsigned char __builtin_loongarch_iocsrrd_b (unsigned int) ++ unsigned short __builtin_loongarch_iocsrrd_h (unsigned int) ++ unsigned int __builtin_loongarch_iocsrrd_w (unsigned int) ++ unsigned long int __builtin_loongarch_iocsrrd_d (unsigned int) ++ void __builtin_loongarch_iocsrwr_b (unsigned char, unsigned int) ++ void __builtin_loongarch_iocsrwr_h (unsigned short, unsigned int) ++ void __builtin_loongarch_iocsrwr_w (unsigned int, unsigned int) ++ void __builtin_loongarch_iocsrwr_d (unsigned long int, unsigned int) ++ ++ void __builtin_loongarch_dbar (imm0_32767) ++ void __builtin_loongarch_ibar (imm0_32767) ++ ++ void __builtin_loongarch_syscall (imm0_32767) ++ void __builtin_loongarch_break (imm0_32767) ++@end smallexample ++ ++@emph{Note:}Since the control register is divided into 32-bit and 64-bit, ++but the access instruction is not distinguished. So GCC renames the control ++instructions when implementing intrinsics. ++ ++Take the csrrd instruction as an example, built-in functions are implemented as follows: ++@smallexample ++ __builtin_loongarch_csrrd_w // When reading the 32-bit control register use. ++ __builtin_loongarch_csrrd_d // When reading the 64-bit control register use. ++@end smallexample ++ ++For the convenience of use, the built-in functions are encapsulated, ++the encapsulated functions and @code{__drdtime_t, __rdtime_t} are ++defined in the @code{larchintrin.h}. So if you call the following ++function you need to include @code{larchintrin.h}. ++ ++@smallexample ++ typedef struct drdtime@{ ++ unsigned long dvalue; ++ unsigned long dtimeid; ++ @} __drdtime_t; ++ ++ typedef struct rdtime@{ ++ unsigned int value; ++ unsigned int timeid; ++ @} __rdtime_t; ++@end smallexample ++ ++@smallexample ++ __drdtime_t __rdtime_d (void) ++ __rdtime_t __rdtimel_w (void) ++ __rdtime_t __rdtimeh_w (void) ++ unsigned int __movfcsr2gr (imm0_31) ++ void __movgr2fcsr (imm0_31, unsigned int) ++ void __cacop_d (imm0_31, unsigned long, imm_n2048_2047) ++ unsigned int __cpucfg (unsigned int) ++ void __asrtle_d (long int, long int) ++ void __asrtgt_d (long int, long int) ++ long int __lddir_d (long int, imm0_31) ++ void __ldpte_d (long int, imm0_31) ++ ++ int __crc_w_b_w (char, int) ++ int __crc_w_h_w (short, int) ++ int __crc_w_w_w (int, int) ++ int __crc_w_d_w (long int, int) ++ int __crcc_w_b_w (char, int) ++ int __crcc_w_h_w (short, int) ++ int __crcc_w_w_w (int, int) ++ int __crcc_w_d_w (long int, int) ++ ++ unsigned int __csrrd_w (imm0_16383) ++ unsigned int __csrwr_w (unsigned int, imm0_16383) ++ unsigned int __csrxchg_w (unsigned int, unsigned int, imm0_16383) ++ unsigned long __csrrd_d (imm0_16383) ++ unsigned long __csrwr_d (unsigned long, imm0_16383) ++ unsigned long __csrxchg_d (unsigned long, unsigned long, imm0_16383) ++ ++ unsigned char __iocsrrd_b (unsigned int) ++ unsigned short __iocsrrd_h (unsigned int) ++ unsigned int __iocsrrd_w (unsigned int) ++ unsigned long __iocsrrd_d (unsigned int) ++ void __iocsrwr_b (unsigned char, unsigned int) ++ void __iocsrwr_h (unsigned short, unsigned int) ++ void __iocsrwr_w (unsigned int, unsigned int) ++ void __iocsrwr_d (unsigned long, unsigned int) ++ ++ void __dbar (imm0_32767) ++ void __ibar (imm0_32767) ++ ++ void __syscall (imm0_32767) ++ void __break (imm0_32767) ++@end smallexample ++ + @node MIPS DSP Built-in Functions + @subsection MIPS DSP Built-in Functions + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-fcopysign-instructions.patch
Added
@@ -0,0 +1,107 @@ +From 41a4945886631a1b2898ae957389d5db18a07141 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Fri, 4 Nov 2022 15:12:22 +0800 +Subject: PATCH 025/124 LoongArch: Add fcopysign instructions + +Add fcopysign.{s,d} with the names copysign{sf,df}3 so GCC will expand +__builtin_copysign{f,} to a single instruction. + +Link: https://sourceware.org/pipermail/libc-alpha/2022-November/143177.html + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (UNSPEC_FCOPYSIGN): New unspec. + (type): Add fcopysign. + (copysign<mode>3): New instruction template. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/fcopysign.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 22 ++++++++++++++++++- + .../gcc.target/loongarch/fcopysign.c | 16 ++++++++++++++ + 2 files changed, 37 insertions(+), 1 deletion(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/fcopysign.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 214b14bdd..bda34d0f3 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -37,6 +37,7 @@ + UNSPEC_FCLASS + UNSPEC_FMAX + UNSPEC_FMIN ++ UNSPEC_FCOPYSIGN + + ;; Override return address for exception handling. + UNSPEC_EH_RETURN +@@ -214,6 +215,7 @@ + ;; fabs floating point absolute value + ;; fneg floating point negation + ;; fcmp floating point compare ++;; fcopysign floating point copysign + ;; fcvt floating point convert + ;; fsqrt floating point square root + ;; frsqrt floating point reciprocal square root +@@ -226,7 +228,7 @@ + "unknown,branch,jump,call,load,fpload,fpidxload,store,fpstore,fpidxstore, + prefetch,prefetchx,condmove,mgtf,mftg,const,arith,logical, + shift,slt,signext,clz,trap,imul,idiv,move, +- fmove,fadd,fmul,fmadd,fdiv,frdiv,fabs,fneg,fcmp,fcvt,fsqrt, ++ fmove,fadd,fmul,fmadd,fdiv,frdiv,fabs,fneg,fcmp,fcopysign,fcvt,fsqrt, + frsqrt,accext,accmod,multi,atomic,syncloop,nop,ghost" + (cond (eq_attr "jirl" "!unset") (const_string "call") + (eq_attr "got" "load") (const_string "load") +@@ -976,6 +978,24 @@ + (set_attr "mode" "<UNITMODE>")) +  + ;; ++;; .................... ++;; ++;; FLOATING POINT COPYSIGN ++;; ++;; .................... ++ ++(define_insn "copysign<mode>3" ++ (set (match_operand:ANYF 0 "register_operand" "=f") ++ (unspec:ANYF (match_operand:ANYF 1 "register_operand" "f") ++ (match_operand:ANYF 2 "register_operand" "f") ++ UNSPEC_FCOPYSIGN)) ++ "TARGET_HARD_FLOAT" ++ "fcopysign.<fmt>\t%0,%1,%2" ++ (set_attr "type" "fcopysign") ++ (set_attr "mode" "<UNITMODE>")) ++ ++ ++;; + ;; ................... + ;; + ;; Count leading zeroes. +diff --git a/gcc/testsuite/gcc.target/loongarch/fcopysign.c b/gcc/testsuite/gcc.target/loongarch/fcopysign.c +new file mode 100644 +index 000000000..058ba2cf5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/fcopysign.c +@@ -0,0 +1,16 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mdouble-float" } */ ++/* { dg-final { scan-assembler "fcopysign\\.s" } } */ ++/* { dg-final { scan-assembler "fcopysign\\.d" } } */ ++ ++double ++my_copysign (double a, double b) ++{ ++ return __builtin_copysign (a, b); ++} ++ ++float ++my_copysignf (float a, float b) ++{ ++ return __builtin_copysignf (a, b); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-flogb.-s-d-instructions-and-expand-log.patch
Added
@@ -0,0 +1,123 @@ +From 2ae587a86bba31b91a127e353c31c9f861ff5326 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 8 Nov 2022 13:42:20 +0800 +Subject: PATCH 030/124 LoongArch: Add flogb.{s,d} instructions and expand + logb{sf,df}2 + +On LoongArch, flogb instructions extract the exponent of a non-negative +floating point value, but produces NaN for negative values. So we need +to add a fabs instruction when we expand logb. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (UNSPEC_FLOGB): New unspec. + (type): Add flogb. + (logb_non_negative<mode>2): New instruction template. + (logb<mode>2): New define_expand. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/flogb.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 35 ++++++++++++++++++++-- + gcc/testsuite/gcc.target/loongarch/flogb.c | 18 +++++++++++ + 2 files changed, 51 insertions(+), 2 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/flogb.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index c141c9add..682ab9617 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -42,6 +42,7 @@ + UNSPEC_FTINTRM + UNSPEC_FTINTRP + UNSPEC_FSCALEB ++ UNSPEC_FLOGB + + ;; Override return address for exception handling. + UNSPEC_EH_RETURN +@@ -217,6 +218,7 @@ + ;; fdiv floating point divide + ;; frdiv floating point reciprocal divide + ;; fabs floating point absolute value ++;; flogb floating point exponent extract + ;; fneg floating point negation + ;; fcmp floating point compare + ;; fcopysign floating point copysign +@@ -233,8 +235,8 @@ + "unknown,branch,jump,call,load,fpload,fpidxload,store,fpstore,fpidxstore, + prefetch,prefetchx,condmove,mgtf,mftg,const,arith,logical, + shift,slt,signext,clz,trap,imul,idiv,move, +- fmove,fadd,fmul,fmadd,fdiv,frdiv,fabs,fneg,fcmp,fcopysign,fcvt,fscaleb, +- fsqrt,frsqrt,accext,accmod,multi,atomic,syncloop,nop,ghost" ++ fmove,fadd,fmul,fmadd,fdiv,frdiv,fabs,flogb,fneg,fcmp,fcopysign,fcvt, ++ fscaleb,fsqrt,frsqrt,accext,accmod,multi,atomic,syncloop,nop,ghost" + (cond (eq_attr "jirl" "!unset") (const_string "call") + (eq_attr "got" "load") (const_string "load") + +@@ -1039,6 +1041,35 @@ + (set_attr "mode" "<UNITMODE>")) +  + ;; ++;; .................... ++;; ++;; FLOATING POINT EXPONENT EXTRACT ++;; ++;; .................... ++ ++(define_insn "logb_non_negative<mode>2" ++ (set (match_operand:ANYF 0 "register_operand" "=f") ++ (unspec:ANYF (match_operand:ANYF 1 "register_operand" "f") ++ UNSPEC_FLOGB)) ++ "TARGET_HARD_FLOAT" ++ "flogb.<fmt>\t%0,%1" ++ (set_attr "type" "flogb") ++ (set_attr "mode" "<UNITMODE>")) ++ ++(define_expand "logb<mode>2" ++ (set (match_operand:ANYF 0 "register_operand") ++ (unspec:ANYF (abs:ANYF (match_operand:ANYF 1 "register_operand")) ++ UNSPEC_FLOGB)) ++ "TARGET_HARD_FLOAT" ++{ ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ ++ emit_insn (gen_abs<mode>2 (tmp, operands1)); ++ emit_insn (gen_logb_non_negative<mode>2 (operands0, tmp)); ++ DONE; ++}) ++ ++;; + ;; ................... + ;; + ;; Count leading zeroes. +diff --git a/gcc/testsuite/gcc.target/loongarch/flogb.c b/gcc/testsuite/gcc.target/loongarch/flogb.c +new file mode 100644 +index 000000000..1daefe54e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/flogb.c +@@ -0,0 +1,18 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mdouble-float -fno-math-errno" } */ ++/* { dg-final { scan-assembler "fabs\\.s" } } */ ++/* { dg-final { scan-assembler "fabs\\.d" } } */ ++/* { dg-final { scan-assembler "flogb\\.s" } } */ ++/* { dg-final { scan-assembler "flogb\\.d" } } */ ++ ++double ++my_logb (double a) ++{ ++ return __builtin_logb (a); ++} ++ ++float ++my_logbf (float a) ++{ ++ return __builtin_logbf (a); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-fscaleb.-s-d-instructions-as-ldexp-sf-.patch
Added
@@ -0,0 +1,155 @@ +From e3d69a3b7a4e00e8bba88b8b4abaa1c17bc083d5 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 8 Nov 2022 12:14:35 +0800 +Subject: PATCH 029/124 LoongArch: Add fscaleb.{s,d} instructions as + ldexp{sf,df}3 + +This allows optimizing __builtin_ldexp{,f} and __builtin_scalbn{,f} with +-fno-math-errno. + +IMODE is added because we can't hard code SI for operand 2: fscaleb.d +instruction always take the high half of both source registers into +account. See my_ldexp_long in the test case. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (UNSPEC_FSCALEB): New unspec. + (type): Add fscaleb. + (IMODE): New mode attr. + (ldexp<mode>3): New instruction template. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/fscaleb.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 26 ++++++++++- + gcc/testsuite/gcc.target/loongarch/fscaleb.c | 48 ++++++++++++++++++++ + 2 files changed, 72 insertions(+), 2 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/fscaleb.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index eb127c346..c141c9add 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -41,6 +41,7 @@ + UNSPEC_FTINT + UNSPEC_FTINTRM + UNSPEC_FTINTRP ++ UNSPEC_FSCALEB + + ;; Override return address for exception handling. + UNSPEC_EH_RETURN +@@ -220,6 +221,7 @@ + ;; fcmp floating point compare + ;; fcopysign floating point copysign + ;; fcvt floating point convert ++;; fscaleb floating point scale + ;; fsqrt floating point square root + ;; frsqrt floating point reciprocal square root + ;; multi multiword sequence (or user asm statements) +@@ -231,8 +233,8 @@ + "unknown,branch,jump,call,load,fpload,fpidxload,store,fpstore,fpidxstore, + prefetch,prefetchx,condmove,mgtf,mftg,const,arith,logical, + shift,slt,signext,clz,trap,imul,idiv,move, +- fmove,fadd,fmul,fmadd,fdiv,frdiv,fabs,fneg,fcmp,fcopysign,fcvt,fsqrt, +- frsqrt,accext,accmod,multi,atomic,syncloop,nop,ghost" ++ fmove,fadd,fmul,fmadd,fdiv,frdiv,fabs,fneg,fcmp,fcopysign,fcvt,fscaleb, ++ fsqrt,frsqrt,accext,accmod,multi,atomic,syncloop,nop,ghost" + (cond (eq_attr "jirl" "!unset") (const_string "call") + (eq_attr "got" "load") (const_string "load") + +@@ -418,6 +420,10 @@ + ;; the controlling mode. + (define_mode_attr HALFMODE (DF "SI") (DI "SI") (TF "DI")) + ++;; This attribute gives the integer mode that has the same size of a ++;; floating-point mode. ++(define_mode_attr IMODE (SF "SI") (DF "DI")) ++ + ;; This code iterator allows signed and unsigned widening multiplications + ;; to use the same template. + (define_code_iterator any_extend sign_extend zero_extend) +@@ -1014,7 +1020,23 @@ + "fcopysign.<fmt>\t%0,%1,%2" + (set_attr "type" "fcopysign") + (set_attr "mode" "<UNITMODE>")) ++ ++;; ++;; .................... ++;; ++;; FLOATING POINT SCALE ++;; ++;; .................... + ++(define_insn "ldexp<mode>3" ++ (set (match_operand:ANYF 0 "register_operand" "=f") ++ (unspec:ANYF (match_operand:ANYF 1 "register_operand" "f") ++ (match_operand:<IMODE> 2 "register_operand" "f") ++ UNSPEC_FSCALEB)) ++ "TARGET_HARD_FLOAT" ++ "fscaleb.<fmt>\t%0,%1,%2" ++ (set_attr "type" "fscaleb") ++ (set_attr "mode" "<UNITMODE>")) +  + ;; + ;; ................... +diff --git a/gcc/testsuite/gcc.target/loongarch/fscaleb.c b/gcc/testsuite/gcc.target/loongarch/fscaleb.c +new file mode 100644 +index 000000000..f18470fbb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/fscaleb.c +@@ -0,0 +1,48 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d -mdouble-float -fno-math-errno" } */ ++/* { dg-final { scan-assembler-times "fscaleb\\.s" 3 } } */ ++/* { dg-final { scan-assembler-times "fscaleb\\.d" 4 } } */ ++/* { dg-final { scan-assembler-times "slli\\.w" 1 } } */ ++ ++double ++my_scalbln (double a, long b) ++{ ++ return __builtin_scalbln (a, b); ++} ++ ++double ++my_scalbn (double a, int b) ++{ ++ return __builtin_scalbn (a, b); ++} ++ ++double ++my_ldexp (double a, int b) ++{ ++ return __builtin_ldexp (a, b); ++} ++ ++float ++my_scalblnf (float a, long b) ++{ ++ return __builtin_scalblnf (a, b); ++} ++ ++float ++my_scalbnf (float a, int b) ++{ ++ return __builtin_scalbnf (a, b); ++} ++ ++float ++my_ldexpf (float a, int b) ++{ ++ return __builtin_ldexpf (a, b); ++} ++ ++/* b must be sign-extended */ ++double ++my_ldexp_long (double a, long b) ++{ ++ return __builtin_ldexp (a, b); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-ftint-rm-rp-.-w-l-.-s-d-instructions.patch
Added
@@ -0,0 +1,220 @@ +From 76d599c6d8f9cf78b51cd76a7ca8fbe11e2cda2b Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Sun, 6 Nov 2022 23:16:49 +0800 +Subject: PATCH 028/124 LoongArch: Add ftint{,rm,rp}.{w,l}.{s,d} instructions + +This allows to optimize the following builtins if -fno-math-errno: + +- __builtin_lrint{,f} +- __builtin_lfloor{,f} +- __builtin_lceil{,f} + +Inspired by +https://gcc.gnu.org/pipermail/gcc-patches/2022-November/605287.html. + +ANYFI is added so the compiler won't try ftint.l.s if -mfpu=32. If we +simply used GPR here an ICE would be triggered with __builtin_lrintf +and -mfpu=32. + +ftint{rm,rp} instructions may raise inexact exception, so they can't be +used if -fno-trapping-math -fno-fp-int-builtin-inexact. + +Note that the .w.{s,d} variants are not tested because we don't support +ILP32 for now. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (UNSPEC_FTINT): New unspec. + (UNSPEC_FTINTRM): Likewise. + (UNSPEC_FTINTRP): Likewise. + (LRINT): New define_int_iterator. + (lrint_pattern): New define_int_attr. + (lrint_submenmonic): Likewise. + (lrint_allow_inexact): Likewise. + (ANYFI): New define_mode_iterator. + (lrint<ANYF><ANYFI>): New instruction template. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/ftint.c: New test. + * gcc.target/loongarch/ftint-no-inexact.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 34 ++++++++++++++ + .../gcc.target/loongarch/ftint-no-inexact.c | 44 +++++++++++++++++++ + gcc/testsuite/gcc.target/loongarch/ftint.c | 44 +++++++++++++++++++ + 3 files changed, 122 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/ftint-no-inexact.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/ftint.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index a14ab14ac..eb127c346 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -38,6 +38,9 @@ + UNSPEC_FMAX + UNSPEC_FMIN + UNSPEC_FCOPYSIGN ++ UNSPEC_FTINT ++ UNSPEC_FTINTRM ++ UNSPEC_FTINTRP + + ;; Override return address for exception handling. + UNSPEC_EH_RETURN +@@ -374,6 +377,11 @@ + (define_mode_iterator ANYF (SF "TARGET_HARD_FLOAT") + (DF "TARGET_DOUBLE_FLOAT")) + ++;; Iterator for fixed-point modes which can be hold by a hardware ++;; floating-point register. ++(define_mode_iterator ANYFI (SI "TARGET_HARD_FLOAT") ++ (DI "TARGET_DOUBLE_FLOAT")) ++ + ;; A mode for which moves involving FPRs may need to be split. + (define_mode_iterator SPLITF + (DF "!TARGET_64BIT && TARGET_DOUBLE_FLOAT") +@@ -515,6 +523,19 @@ + (define_code_attr sel (eq "masknez") (ne "maskeqz")) + (define_code_attr selinv (eq "maskeqz") (ne "masknez")) + ++;; Iterator and attributes for floating-point to fixed-point conversion ++;; instructions. ++(define_int_iterator LRINT UNSPEC_FTINT UNSPEC_FTINTRM UNSPEC_FTINTRP) ++(define_int_attr lrint_pattern (UNSPEC_FTINT "lrint") ++ (UNSPEC_FTINTRM "lfloor") ++ (UNSPEC_FTINTRP "lceil")) ++(define_int_attr lrint_submenmonic (UNSPEC_FTINT "") ++ (UNSPEC_FTINTRM "rm") ++ (UNSPEC_FTINTRP "rp")) ++(define_int_attr lrint_allow_inexact (UNSPEC_FTINT "1") ++ (UNSPEC_FTINTRM "0") ++ (UNSPEC_FTINTRP "0")) ++ + ;; + ;; .................... + ;; +@@ -2022,6 +2043,19 @@ + (set_attr "type" "fcvt") + (set_attr "mode" "<MODE>")) + ++;; Convert floating-point numbers to integers ++(define_insn "<lrint_pattern><ANYF:mode><ANYFI:mode>2" ++ (set (match_operand:ANYFI 0 "register_operand" "=f") ++ (unspec:ANYFI (match_operand:ANYF 1 "register_operand" "f") ++ LRINT)) ++ "TARGET_HARD_FLOAT && ++ (<lrint_allow_inexact> ++ || flag_fp_int_builtin_inexact ++ || !flag_trapping_math)" ++ "ftint<lrint_submenmonic>.<ANYFI:ifmt>.<ANYF:fmt> %0,%1" ++ (set_attr "type" "fcvt") ++ (set_attr "mode" "<ANYF:MODE>")) ++ + ;; Load the low word of operand 0 with operand 1. + (define_insn "load_low<mode>" + (set (match_operand:SPLITF 0 "register_operand" "=f,f") +diff --git a/gcc/testsuite/gcc.target/loongarch/ftint-no-inexact.c b/gcc/testsuite/gcc.target/loongarch/ftint-no-inexact.c +new file mode 100644 +index 000000000..88b83a9c0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/ftint-no-inexact.c +@@ -0,0 +1,44 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -mdouble-float -fno-math-errno -fno-fp-int-builtin-inexact" } */ ++/* { dg-final { scan-assembler "ftint\\.l\\.s" } } */ ++/* { dg-final { scan-assembler "ftint\\.l\\.d" } } */ ++/* { dg-final { scan-assembler-not "ftintrm\\.l\\.s" } } */ ++/* { dg-final { scan-assembler-not "ftintrm\\.l\\.d" } } */ ++/* { dg-final { scan-assembler-not "ftintrp\\.l\\.s" } } */ ++/* { dg-final { scan-assembler-not "ftintrp\\.l\\.d" } } */ ++ ++long ++my_lrint (double a) ++{ ++ return __builtin_lrint (a); ++} ++ ++long ++my_lrintf (float a) ++{ ++ return __builtin_lrintf (a); ++} ++ ++long ++my_lfloor (double a) ++{ ++ return __builtin_lfloor (a); ++} ++ ++long ++my_lfloorf (float a) ++{ ++ return __builtin_lfloorf (a); ++} ++ ++long ++my_lceil (double a) ++{ ++ return __builtin_lceil (a); ++} ++ ++long ++my_lceilf (float a) ++{ ++ return __builtin_lceilf (a); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/ftint.c b/gcc/testsuite/gcc.target/loongarch/ftint.c +new file mode 100644 +index 000000000..7a326a454 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/ftint.c +@@ -0,0 +1,44 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -mdouble-float -fno-math-errno -ffp-int-builtin-inexact" } */ ++/* { dg-final { scan-assembler "ftint\\.l\\.s" } } */ ++/* { dg-final { scan-assembler "ftint\\.l\\.d" } } */ ++/* { dg-final { scan-assembler "ftintrm\\.l\\.s" } } */ ++/* { dg-final { scan-assembler "ftintrm\\.l\\.d" } } */ ++/* { dg-final { scan-assembler "ftintrp\\.l\\.s" } } */ ++/* { dg-final { scan-assembler "ftintrp\\.l\\.d" } } */ ++ ++long ++my_lrint (double a) ++{ ++ return __builtin_lrint (a); ++} ++ ++long ++my_lrintf (float a) ++{ ++ return __builtin_lrintf (a); ++} ++ ++long ++my_lfloor (double a) ++{ ++ return __builtin_lfloor (a); ++} ++ ++long ++my_lfloorf (float a) ++{ ++ return __builtin_lfloorf (a); ++} ++ ++long ++my_lceil (double a) ++{ ++ return __builtin_lceil (a); ++} ++ ++long ++my_lceilf (float a) ++{ ++ return __builtin_lceilf (a); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-new-code-model-medium.patch
Added
@@ -0,0 +1,1051 @@ +From 893322f214fbb916dc8eb6be5acbf7bdb7785e77 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Sat, 20 Aug 2022 15:19:51 +0800 +Subject: PATCH 012/124 LoongArch: Add new code model 'medium'. + +The function jump instruction in normal mode is 'bl', +so the scope of the function jump is +-128MB. + +Now we've added support for 'medium' mode, this mode is +to complete the function jump through two instructions: + pcalau12i + jirl +So in this mode the function jump range is increased to +-2GB. + +Compared with 'normal' mode, 'medium' mode only affects the +jump range of functions. + +gcc/ChangeLog: + + * config/loongarch/genopts/loongarch-strings: Support code model medium. + * config/loongarch/genopts/loongarch.opt.in: Likewise. + * config/loongarch/loongarch-def.c: Likewise. + * config/loongarch/loongarch-def.h (CMODEL_LARGE): Likewise. + (CMODEL_EXTREME): Likewise. + (N_CMODEL_TYPES): Likewise. + (CMODEL_MEDIUM): Likewise. + * config/loongarch/loongarch-opts.cc: Likewise. + * config/loongarch/loongarch-opts.h (TARGET_CMODEL_MEDIUM): Likewise. + * config/loongarch/loongarch-str.h (STR_CMODEL_MEDIUM): Likewise. + * config/loongarch/loongarch.cc (loongarch_call_tls_get_addr): + Tls symbol Loading support medium mode. + (loongarch_legitimize_call_address): When medium mode, make a symbolic + jump with two instructions. + (loongarch_option_override_internal): Support medium. + * config/loongarch/loongarch.md (@pcalau12i<mode>): New template. + (@sibcall_internal_1<mode>): New function call templates added to support + medium mode. + (@sibcall_value_internal_1<mode>): Likewise. + (@sibcall_value_multiple_internal_1<mode>): Likewise. + (@call_internal_1<mode>): Likewise. + (@call_value_internal_1<mode>): Likewise. + (@call_value_multiple_internal_1<mode>): Likewise. + * config/loongarch/loongarch.opt: Support medium. + * config/loongarch/predicates.md: Add processing about medium mode. + * doc/invoke.texi: Document for '-mcmodel=medium'. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/func-call-medium-1.c: New test. + * gcc.target/loongarch/func-call-medium-2.c: New test. + * gcc.target/loongarch/func-call-medium-3.c: New test. + * gcc.target/loongarch/func-call-medium-4.c: New test. + * gcc.target/loongarch/func-call-medium-5.c: New test. + * gcc.target/loongarch/func-call-medium-6.c: New test. + * gcc.target/loongarch/func-call-medium-7.c: New test. + * gcc.target/loongarch/func-call-medium-8.c: New test. + * gcc.target/loongarch/tls-gd-noplt.c: Add compile parameter '-mexplicit-relocs'. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/genopts/loongarch-strings | 1 + + gcc/config/loongarch/genopts/loongarch.opt.in | 3 + + gcc/config/loongarch/loongarch-def.c | 1 + + gcc/config/loongarch/loongarch-def.h | 7 +- + gcc/config/loongarch/loongarch-opts.cc | 15 ++- + gcc/config/loongarch/loongarch-opts.h | 1 + + gcc/config/loongarch/loongarch-str.h | 1 + + gcc/config/loongarch/loongarch.cc | 123 +++++++++++++---- + gcc/config/loongarch/loongarch.md | 125 +++++++++++++++++- + gcc/config/loongarch/loongarch.opt | 3 + + gcc/config/loongarch/predicates.md | 15 ++- + gcc/doc/invoke.texi | 3 + + .../gcc.target/loongarch/func-call-medium-1.c | 41 ++++++ + .../gcc.target/loongarch/func-call-medium-2.c | 41 ++++++ + .../gcc.target/loongarch/func-call-medium-3.c | 41 ++++++ + .../gcc.target/loongarch/func-call-medium-4.c | 41 ++++++ + .../gcc.target/loongarch/func-call-medium-5.c | 42 ++++++ + .../gcc.target/loongarch/func-call-medium-6.c | 42 ++++++ + .../gcc.target/loongarch/func-call-medium-7.c | 43 ++++++ + .../gcc.target/loongarch/func-call-medium-8.c | 42 ++++++ + .../gcc.target/loongarch/tls-gd-noplt.c | 4 +- + 21 files changed, 595 insertions(+), 40 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c + +diff --git a/gcc/config/loongarch/genopts/loongarch-strings b/gcc/config/loongarch/genopts/loongarch-strings +index cb88ed56b..44ebb7ab1 100644 +--- a/gcc/config/loongarch/genopts/loongarch-strings ++++ b/gcc/config/loongarch/genopts/loongarch-strings +@@ -54,5 +54,6 @@ OPTSTR_CMODEL cmodel + STR_CMODEL_NORMAL normal + STR_CMODEL_TINY tiny + STR_CMODEL_TS tiny-static ++STR_CMODEL_MEDIUM medium + STR_CMODEL_LARGE large + STR_CMODEL_EXTREME extreme +diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in +index a571b6b75..ebdd9538d 100644 +--- a/gcc/config/loongarch/genopts/loongarch.opt.in ++++ b/gcc/config/loongarch/genopts/loongarch.opt.in +@@ -172,6 +172,9 @@ Enum(cmodel) String(@@STR_CMODEL_TINY@@) Value(CMODEL_TINY) + EnumValue + Enum(cmodel) String(@@STR_CMODEL_TS@@) Value(CMODEL_TINY_STATIC) + ++EnumValue ++Enum(cmodel) String(@@STR_CMODEL_MEDIUM@@) Value(CMODEL_MEDIUM) ++ + EnumValue + Enum(cmodel) String(@@STR_CMODEL_LARGE@@) Value(CMODEL_LARGE) + +diff --git a/gcc/config/loongarch/loongarch-def.c b/gcc/config/loongarch/loongarch-def.c +index c8769b7d6..cbf995d81 100644 +--- a/gcc/config/loongarch/loongarch-def.c ++++ b/gcc/config/loongarch/loongarch-def.c +@@ -152,6 +152,7 @@ loongarch_cmodel_strings = { + CMODEL_NORMAL = STR_CMODEL_NORMAL, + CMODEL_TINY = STR_CMODEL_TINY, + CMODEL_TINY_STATIC = STR_CMODEL_TS, ++ CMODEL_MEDIUM = STR_CMODEL_MEDIUM, + CMODEL_LARGE = STR_CMODEL_LARGE, + CMODEL_EXTREME = STR_CMODEL_EXTREME, + }; +diff --git a/gcc/config/loongarch/loongarch-def.h b/gcc/config/loongarch/loongarch-def.h +index c2c35b6ba..b5985f070 100644 +--- a/gcc/config/loongarch/loongarch-def.h ++++ b/gcc/config/loongarch/loongarch-def.h +@@ -82,9 +82,10 @@ extern const char* loongarch_cmodel_strings; + #define CMODEL_NORMAL 0 + #define CMODEL_TINY 1 + #define CMODEL_TINY_STATIC 2 +-#define CMODEL_LARGE 3 +-#define CMODEL_EXTREME 4 +-#define N_CMODEL_TYPES 5 ++#define CMODEL_MEDIUM 3 ++#define CMODEL_LARGE 4 ++#define CMODEL_EXTREME 5 ++#define N_CMODEL_TYPES 6 + + /* enum switches */ + /* The "SW_" codes represent command-line switches (options that +diff --git a/gcc/config/loongarch/loongarch-opts.cc b/gcc/config/loongarch/loongarch-opts.cc +index 2ae89f234..e13eafb58 100644 +--- a/gcc/config/loongarch/loongarch-opts.cc ++++ b/gcc/config/loongarch/loongarch-opts.cc +@@ -376,11 +376,24 @@ fallback: + + /* 5. Target code model */ + t.cmodel = constrained.cmodel ? opt_cmodel : CMODEL_NORMAL; +- if (t.cmodel != CMODEL_NORMAL && t.cmodel != CMODEL_EXTREME) ++ ++ switch (t.cmodel) + { ++ case CMODEL_TINY: ++ case CMODEL_TINY_STATIC: ++ case CMODEL_LARGE: + warning (0, "%qs is not supported, now cmodel is set to %qs", + loongarch_cmodel_stringst.cmodel, "normal"); + t.cmodel = CMODEL_NORMAL; ++ break; ++ ++ case CMODEL_NORMAL: ++ case CMODEL_MEDIUM: ++ case CMODEL_EXTREME: ++ break; ++ ++ default: ++ gcc_unreachable (); + } + + /* Cleanup and return. */ +diff --git a/gcc/config/loongarch/loongarch-opts.h b/gcc/config/loongarch/loongarch-opts.h +index da24ecd2b..3523a4cf7 100644 +--- a/gcc/config/loongarch/loongarch-opts.h ++++ b/gcc/config/loongarch/loongarch-opts.h +@@ -46,6 +46,7 @@ loongarch_config_target (struct loongarch_target *target, + #define TARGET_CMODEL_NORMAL (la_target.cmodel == CMODEL_NORMAL) + #define TARGET_CMODEL_TINY (la_target.cmodel == CMODEL_TINY) + #define TARGET_CMODEL_TINY_STATIC (la_target.cmodel == CMODEL_TINY_STATIC) ++#define TARGET_CMODEL_MEDIUM (la_target.cmodel == CMODEL_MEDIUM) + #define TARGET_CMODEL_LARGE (la_target.cmodel == CMODEL_LARGE) + #define TARGET_CMODEL_EXTREME (la_target.cmodel == CMODEL_EXTREME) + +diff --git a/gcc/config/loongarch/loongarch-str.h b/gcc/config/loongarch/loongarch-str.h +index 0e8889b8c..9f1b0989c 100644 +--- a/gcc/config/loongarch/loongarch-str.h ++++ b/gcc/config/loongarch/loongarch-str.h +@@ -53,6 +53,7 @@ along with GCC; see the file COPYING3. If not see + #define STR_CMODEL_NORMAL "normal" + #define STR_CMODEL_TINY "tiny" + #define STR_CMODEL_TS "tiny-static" ++#define STR_CMODEL_MEDIUM "medium" + #define STR_CMODEL_LARGE "large" + #define STR_CMODEL_EXTREME "extreme" + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 1a33f668f..04c4ddaed 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -2461,44 +2461,96 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + } + + if (flag_plt) +- insn = emit_call_insn (gen_call_value_internal (v0, +- loongarch_tls_symbol, +- const0_rtx)); +- else + { +- rtx dest = gen_reg_rtx (Pmode); +- +- if (TARGET_CMODEL_EXTREME) ++ switch (la_opt_cmodel) + { +- gcc_assert (TARGET_EXPLICIT_RELOCS); ++ case CMODEL_NORMAL: ++ insn = emit_call_insn (gen_call_value_internal (v0, ++ loongarch_tls_symbol, ++ const0_rtx)); ++ break; + +- rtx tmp1 = gen_reg_rtx (Pmode); +- rtx high = gen_reg_rtx (Pmode); ++ case CMODEL_MEDIUM: ++ { ++ rtx reg = gen_reg_rtx (Pmode); ++ if (TARGET_EXPLICIT_RELOCS) ++ { ++ emit_insn (gen_pcalau12i (Pmode, reg, loongarch_tls_symbol)); ++ rtx call = gen_call_value_internal_1 (Pmode, v0, reg, ++ loongarch_tls_symbol, ++ const0_rtx); ++ insn = emit_call_insn (call); ++ } ++ else ++ { ++ emit_move_insn (reg, loongarch_tls_symbol); ++ insn = emit_call_insn (gen_call_value_internal (v0, ++ reg, ++ const0_rtx)); ++ } ++ break; ++ } + +- loongarch_emit_move (high, +- gen_rtx_HIGH (Pmode, loongarch_tls_symbol)); +- loongarch_emit_move (tmp1, gen_rtx_LO_SUM (Pmode, +- gen_rtx_REG (Pmode, 0), +- loongarch_tls_symbol)); +- emit_insn (gen_lui_h_lo20 (tmp1, tmp1, loongarch_tls_symbol)); +- emit_insn (gen_lui_h_hi12 (tmp1, tmp1, loongarch_tls_symbol)); +- loongarch_emit_move (dest, +- gen_rtx_MEM (Pmode, +- gen_rtx_PLUS (Pmode, high, tmp1))); ++ /* code model extreme not support plt. */ ++ case CMODEL_EXTREME: ++ case CMODEL_LARGE: ++ case CMODEL_TINY: ++ case CMODEL_TINY_STATIC: ++ default: ++ gcc_unreachable (); + } +- else ++ } ++ else ++ { ++ rtx dest = gen_reg_rtx (Pmode); ++ ++ switch (la_opt_cmodel) + { +- if (TARGET_EXPLICIT_RELOCS) ++ case CMODEL_NORMAL: ++ case CMODEL_MEDIUM: ++ { ++ if (TARGET_EXPLICIT_RELOCS) ++ { ++ rtx high = gen_reg_rtx (Pmode); ++ loongarch_emit_move (high, ++ gen_rtx_HIGH (Pmode, ++ loongarch_tls_symbol)); ++ emit_insn (gen_ld_from_got (Pmode, dest, high, ++ loongarch_tls_symbol)); ++ } ++ else ++ loongarch_emit_move (dest, loongarch_tls_symbol); ++ break; ++ } ++ ++ case CMODEL_EXTREME: + { ++ gcc_assert (TARGET_EXPLICIT_RELOCS); ++ ++ rtx tmp1 = gen_reg_rtx (Pmode); + rtx high = gen_reg_rtx (Pmode); ++ + loongarch_emit_move (high, + gen_rtx_HIGH (Pmode, loongarch_tls_symbol)); +- emit_insn (gen_ld_from_got (Pmode, dest, high, +- loongarch_tls_symbol)); ++ loongarch_emit_move (tmp1, gen_rtx_LO_SUM (Pmode, ++ gen_rtx_REG (Pmode, 0), ++ loongarch_tls_symbol)); ++ emit_insn (gen_lui_h_lo20 (tmp1, tmp1, loongarch_tls_symbol)); ++ emit_insn (gen_lui_h_hi12 (tmp1, tmp1, loongarch_tls_symbol)); ++ loongarch_emit_move (dest, ++ gen_rtx_MEM (Pmode, ++ gen_rtx_PLUS (Pmode, ++ high, tmp1))); + } +- else +- loongarch_emit_move (dest, loongarch_tls_symbol); ++ break; ++ ++ case CMODEL_LARGE: ++ case CMODEL_TINY: ++ case CMODEL_TINY_STATIC: ++ default: ++ gcc_unreachable (); + } ++ + insn = emit_call_insn (gen_call_value_internal (v0, dest, const0_rtx)); + } + +@@ -2618,6 +2670,24 @@ loongarch_legitimize_call_address (rtx addr) + loongarch_emit_move (reg, addr); + return reg; + } ++ ++ enum loongarch_symbol_type symbol_type = loongarch_classify_symbol (addr); ++ ++ /* Split function call insn 'bl sym' or 'bl %plt(sym)' to : ++ pcalau12i $rd, %pc_hi20(sym) ++ jr $rd, %pc_lo12(sym). */ ++ ++ if (TARGET_CMODEL_MEDIUM ++ && TARGET_EXPLICIT_RELOCS ++ && (SYMBOL_REF_P (addr) || LABEL_REF_P (addr)) ++ && (symbol_type == SYMBOL_PCREL ++ || (symbol_type == SYMBOL_GOT_DISP && flag_plt))) ++ { ++ rtx reg = gen_reg_rtx (Pmode); ++ emit_insn (gen_pcalau12i (Pmode, reg, addr)); ++ return gen_rtx_LO_SUM (Pmode, reg, addr); ++ } ++ + return addr; + } + +@@ -5996,6 +6066,7 @@ loongarch_option_override_internal (struct gcc_options *opts) + break; + + case CMODEL_TINY_STATIC: ++ case CMODEL_MEDIUM: + case CMODEL_NORMAL: + case CMODEL_TINY: + case CMODEL_LARGE: +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 8fc10444c..3787fd823 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -59,11 +59,15 @@ + UNSPEC_CRCC + + UNSPEC_LOAD_FROM_GOT ++ UNSPEC_PCALAU12I + UNSPEC_ORI_L_LO12 + UNSPEC_LUI_L_HI20 + UNSPEC_LUI_H_LO20 + UNSPEC_LUI_H_HI12 + UNSPEC_TLS_LOW ++ ++ UNSPEC_SIBCALL_VALUE_MULTIPLE_INTERNAL_1 ++ UNSPEC_CALL_VALUE_MULTIPLE_INTERNAL_1 + ) + + (define_c_enum "unspecv" +@@ -1946,6 +1950,14 @@ + (set_attr "type" "move") + ) + ++(define_insn "@pcalau12i<mode>" ++ (set (match_operand:P 0 "register_operand" "=j") ++ (unspec:P (match_operand:P 1 "symbolic_operand" "") ++ UNSPEC_PCALAU12I)) ++ "" ++ "pcalau12i\t%0,%%pc_hi20(%1)" ++ (set_attr "type" "move")) ++ + (define_insn "@ori_l_lo12<mode>" + (set (match_operand:P 0 "register_operand" "=r") + (unspec:P (match_operand:P 1 "register_operand" "r") +@@ -2877,7 +2889,12 @@ + { + rtx target = loongarch_legitimize_call_address (XEXP (operands0, 0)); + +- emit_call_insn (gen_sibcall_internal (target, operands1)); ++ if (GET_CODE (target) == LO_SUM) ++ emit_call_insn (gen_sibcall_internal_1 (Pmode, XEXP (target, 0), ++ XEXP (target, 1), ++ operands1)); ++ else ++ emit_call_insn (gen_sibcall_internal (target, operands1)); + DONE; + }) + +@@ -2891,6 +2908,14 @@ + b\t%%plt(%0)" + (set_attr "jirl" "indirect,direct,direct")) + ++(define_insn "@sibcall_internal_1<mode>" ++ (call (mem:P (lo_sum:P (match_operand:P 0 "register_operand" "j") ++ (match_operand:P 1 "symbolic_operand" ""))) ++ (match_operand 2 "" "")) ++ "SIBLING_CALL_P (insn) && TARGET_CMODEL_MEDIUM" ++ "jirl\t$r0,%0,%%pc_lo12(%1)" ++ (set_attr "jirl" "indirect")) ++ + (define_expand "sibcall_value" + (parallel (set (match_operand 0 "") + (call (match_operand 1 "") +@@ -2906,7 +2931,14 @@ + rtx arg1 = XEXP (XVECEXP (operands0,0, 0), 0); + rtx arg2 = XEXP (XVECEXP (operands0,0, 1), 0); + +- emit_call_insn (gen_sibcall_value_multiple_internal (arg1, target, ++ if (GET_CODE (target) == LO_SUM) ++ emit_call_insn (gen_sibcall_value_multiple_internal_1 (Pmode, arg1, ++ XEXP (target, 0), ++ XEXP (target, 1), ++ operands2, ++ arg2)); ++ else ++ emit_call_insn (gen_sibcall_value_multiple_internal (arg1, target, + operands2, + arg2)); + } +@@ -2916,7 +2948,13 @@ + if (GET_CODE (operands0) == PARALLEL && XVECLEN (operands0, 0) == 1) + operands0 = XEXP (XVECEXP (operands0, 0, 0), 0); + +- emit_call_insn (gen_sibcall_value_internal (operands0, target, ++ if (GET_CODE (target) == LO_SUM) ++ emit_call_insn (gen_sibcall_value_internal_1 (Pmode, operands0, ++ XEXP (target, 0), ++ XEXP (target, 1), ++ operands2)); ++ else ++ emit_call_insn (gen_sibcall_value_internal (operands0, target, + operands2)); + } + DONE; +@@ -2933,6 +2971,15 @@ + b\t%%plt(%1)" + (set_attr "jirl" "indirect,direct,direct")) + ++(define_insn "@sibcall_value_internal_1<mode>" ++ (set (match_operand 0 "register_operand" "") ++ (call (mem:P (lo_sum:P (match_operand:P 1 "register_operand" "j") ++ (match_operand:P 2 "symbolic_operand" ""))) ++ (match_operand 3 "" ""))) ++ "SIBLING_CALL_P (insn) && TARGET_CMODEL_MEDIUM" ++ "jirl\t$r0,%1,%%pc_lo12(%2)" ++ (set_attr "jirl" "indirect")) ++ + (define_insn "sibcall_value_multiple_internal" + (set (match_operand 0 "register_operand" "") + (call (mem:SI (match_operand 1 "call_insn_operand" "j,c,b")) +@@ -2947,6 +2994,21 @@ + b\t%%plt(%1)" + (set_attr "jirl" "indirect,direct,direct")) + ++(define_insn "@sibcall_value_multiple_internal_1<mode>" ++ (set (match_operand 0 "register_operand" "") ++ (call (mem:P (unspec:P (match_operand:P 1 "register_operand" "j") ++ (match_operand:P 2 "symbolic_operand" "") ++ UNSPEC_SIBCALL_VALUE_MULTIPLE_INTERNAL_1)) ++ (match_operand 3 "" ""))) ++ (set (match_operand 4 "register_operand" "") ++ (call (mem:P (unspec:P (match_dup 1) ++ (match_dup 2) ++ UNSPEC_SIBCALL_VALUE_MULTIPLE_INTERNAL_1)) ++ (match_dup 3))) ++ "SIBLING_CALL_P (insn) && TARGET_CMODEL_MEDIUM" ++ "jirl\t$r0,%1,%%pc_lo12(%2)" ++ (set_attr "jirl" "indirect")) ++ + (define_expand "call" + (parallel (call (match_operand 0 "") + (match_operand 1 "")) +@@ -2956,7 +3018,11 @@ + { + rtx target = loongarch_legitimize_call_address (XEXP (operands0, 0)); + +- emit_call_insn (gen_call_internal (target, operands1)); ++ if (GET_CODE (target) == LO_SUM) ++ emit_call_insn (gen_call_internal_1 (Pmode, XEXP (target, 0), ++ XEXP (target, 1), operands1)); ++ else ++ emit_call_insn (gen_call_internal (target, operands1)); + DONE; + }) + +@@ -2971,6 +3037,15 @@ + bl\t%%plt(%0)" + (set_attr "jirl" "indirect,direct,direct")) + ++(define_insn "@call_internal_1<mode>" ++ (call (mem:P (lo_sum:P (match_operand:P 0 "register_operand" "j") ++ (match_operand:P 1 "symbolic_operand" ""))) ++ (match_operand 2 "" "")) ++ (clobber (reg:SI RETURN_ADDR_REGNUM)) ++ "TARGET_CMODEL_MEDIUM" ++ "jirl\t$r1,%0,%%pc_lo12(%1)" ++ (set_attr "jirl" "indirect")) ++ + (define_expand "call_value" + (parallel (set (match_operand 0 "") + (call (match_operand 1 "") +@@ -2985,7 +3060,13 @@ + rtx arg1 = XEXP (XVECEXP (operands0, 0, 0), 0); + rtx arg2 = XEXP (XVECEXP (operands0, 0, 1), 0); + +- emit_call_insn (gen_call_value_multiple_internal (arg1, target, ++ if (GET_CODE (target) == LO_SUM) ++ emit_call_insn (gen_call_value_multiple_internal_1 (Pmode, arg1, ++ XEXP (target, 0), ++ XEXP (target, 1), ++ operands2, arg2)); ++ else ++ emit_call_insn (gen_call_value_multiple_internal (arg1, target, + operands2, arg2)); + } + else +@@ -2994,7 +3075,13 @@ + if (GET_CODE (operands0) == PARALLEL && XVECLEN (operands0, 0) == 1) + operands0 = XEXP (XVECEXP (operands0, 0, 0), 0); + +- emit_call_insn (gen_call_value_internal (operands0, target, ++ if (GET_CODE (target) == LO_SUM) ++ emit_call_insn (gen_call_value_internal_1 (Pmode, operands0, ++ XEXP (target, 0), ++ XEXP (target, 1), ++ operands2)); ++ else ++ emit_call_insn (gen_call_value_internal (operands0, target, + operands2)); + } + DONE; +@@ -3012,6 +3099,16 @@ + bl\t%%plt(%1)" + (set_attr "jirl" "indirect,direct,direct")) + ++(define_insn "@call_value_internal_1<mode>" ++ (set (match_operand 0 "register_operand" "") ++ (call (mem:P (lo_sum:P (match_operand:P 1 "register_operand" "j") ++ (match_operand:P 2 "symbolic_operand" ""))) ++ (match_operand 3 "" ""))) ++ (clobber (reg:SI RETURN_ADDR_REGNUM)) ++ "TARGET_CMODEL_MEDIUM" ++ "jirl\t$r1,%1,%%pc_lo12(%2)" ++ (set_attr "jirl" "indirect")) ++ + (define_insn "call_value_multiple_internal" + (set (match_operand 0 "register_operand" "") + (call (mem:SI (match_operand 1 "call_insn_operand" "e,c,b")) +@@ -3027,6 +3124,22 @@ + bl\t%%plt(%1)" + (set_attr "jirl" "indirect,direct,direct")) + ++(define_insn "@call_value_multiple_internal_1<mode>" ++ (set (match_operand 0 "register_operand" "") ++ (call (mem:P (unspec:P (match_operand:P 1 "register_operand" "j") ++ (match_operand:P 2 "symbolic_operand" "") ++ UNSPEC_CALL_VALUE_MULTIPLE_INTERNAL_1)) ++ (match_operand 3 "" ""))) ++ (set (match_operand 4 "register_operand" "") ++ (call (mem:P (unspec:P (match_dup 1) ++ (match_dup 2) ++ UNSPEC_CALL_VALUE_MULTIPLE_INTERNAL_1)) ++ (match_dup 3))) ++ (clobber (reg:SI RETURN_ADDR_REGNUM)) ++ "TARGET_CMODEL_MEDIUM" ++ "jirl\t$r1,%1,%%pc_lo12(%2)" ++ (set_attr "jirl" "indirect")) ++ + + ;; Call subroutine returning any type. + (define_expand "untyped_call" +diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt +index 9df7e1872..639523421 100644 +--- a/gcc/config/loongarch/loongarch.opt ++++ b/gcc/config/loongarch/loongarch.opt +@@ -179,6 +179,9 @@ Enum(cmodel) String(tiny) Value(CMODEL_TINY) + EnumValue + Enum(cmodel) String(tiny-static) Value(CMODEL_TINY_STATIC) + ++EnumValue ++Enum(cmodel) String(medium) Value(CMODEL_MEDIUM) ++ + EnumValue + Enum(cmodel) String(large) Value(CMODEL_LARGE) + +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index e38c6fbdd..8bd0c1376 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -123,16 +123,27 @@ + if (offset != const0_rtx) + return false; + ++ /* When compiling with '-mcmodel=medium -mexplicit-relocs' ++ symbols are splited in loongarch_legitimize_call_address. ++ ++ When compiling with '-mcmodel=medium -mno-explicit-relocs', ++ first obtain the symbolic address or the address of the ++ plt entry, and then perform an indirect jump, so return false. */ ++ + switch (symbol_type) + { + case SYMBOL_PCREL: +- if (TARGET_CMODEL_EXTREME) ++ if (TARGET_CMODEL_EXTREME ++ || (TARGET_CMODEL_MEDIUM && !TARGET_EXPLICIT_RELOCS)) + return false; + else + return 1; + + case SYMBOL_GOT_DISP: +- if (TARGET_CMODEL_EXTREME || !flag_plt) ++ if (TARGET_CMODEL_EXTREME ++ || !flag_plt ++ || (flag_plt && TARGET_CMODEL_MEDIUM ++ && !TARGET_EXPLICIT_RELOCS)) + return false; + else + return 1; +diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi +index c4f83e62a..2a5592516 100644 +--- a/gcc/doc/invoke.texi ++++ b/gcc/doc/invoke.texi +@@ -24625,6 +24625,9 @@ Set the code model to one of: + The text segment must be within 128MB addressing space. The data segment must + be within 2GB addressing space. + ++@item medium ++The text segment and data segment must be within 2GB addressing space. ++ + @item large (Not implemented yet) + + @item extreme +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c +new file mode 100644 +index 000000000..276d73e5e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c +@@ -0,0 +1,41 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mno-explicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*la\.global\t.*f\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c +new file mode 100644 +index 000000000..237821c06 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c +@@ -0,0 +1,41 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mno-explicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*la\.local\t.*f\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c +new file mode 100644 +index 000000000..9a6e16103 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c +@@ -0,0 +1,41 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mno-explicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*la\.global\t.*f\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c +new file mode 100644 +index 000000000..2577e3452 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c +@@ -0,0 +1,41 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mno-explicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*la\.local\t.*f\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c +new file mode 100644 +index 000000000..d70b6ea46 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c +@@ -0,0 +1,42 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mexplicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i.*%pc_hi20\\(g\\)\n\tjirl.*pc_lo12\\(g\\)" } } */ ++/* { dg-final { scan-assembler "test1:.*pcalau12i.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */ ++/* { dg-final { scan-assembler "test2:.*pcalau12i.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%pc_hi20\\(__tls_get_addr\\)\n\t.*\n\tjirl.*%pc_lo12\\(__tls_get_addr\\)" } } */ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c +new file mode 100644 +index 000000000..f963a9944 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c +@@ -0,0 +1,42 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mexplicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i.*%pc_hi20\\(g\\)\n\tjirl.*pc_lo12\\(g\\)" } } */ ++/* { dg-final { scan-assembler "test1:.*pcalau12i.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */ ++/* { dg-final { scan-assembler "test2:.*pcalau12i.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%pc_hi20\\(__tls_get_addr\\)\n\t.*\n\tjirl.*%pc_lo12\\(__tls_get_addr\\)" } } */ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c +new file mode 100644 +index 000000000..f2818b2da +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c +@@ -0,0 +1,43 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mexplicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%got_pc_hi20\\(f\\)\n\tld\.d\t.*%got_pc_lo12\\(f\\)\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test2:.*pcalau12i\t.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" } } */ ++ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c +new file mode 100644 +index 000000000..7fa873d84 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c +@@ -0,0 +1,42 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mexplicit-relocs -mcmodel=medium" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */ ++/* { dg-final { scan-assembler "test2:.*pcalau12i\t.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" } } */ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test3 (void) ++{ ++ a = 10; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c b/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c +index 32a0acf9b..375663286 100644 +--- a/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c ++++ b/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c +@@ -1,6 +1,6 @@ + /* { dg-do compile } */ +-/* { dg-options "-O2 -fno-plt -mcmodel=normal" } */ +-/* { dg-final { scan-assembler "pcalau12i\t.*%got_pc_hi20\\(__tls_get_addr\\)" } } */ ++/* { dg-options "-O0 -fno-plt -mcmodel=normal -mexplicit-relocs" } */ ++/* { dg-final { scan-assembler "pcalau12i\t.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" } } */ + + __attribute__ ((tls_model ("global-dynamic"))) __thread int a; + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-prefetch-instructions.patch
Added
@@ -0,0 +1,158 @@ +From 52a41006c2e8141a42de93ffcc2c040e034244b2 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Wed, 16 Nov 2022 09:25:14 +0800 +Subject: PATCH 031/124 LoongArch: Add prefetch instructions. + +Enable sw prefetching at -O3 and higher. + +Co-Authored-By: xujiahao <xujiahao@loongson.cn> + +gcc/ChangeLog: + + * config/loongarch/constraints.md (ZD): New constraint. + * config/loongarch/loongarch-def.c: Initial number of parallel prefetch. + * config/loongarch/loongarch-tune.h (struct loongarch_cache): + Define number of parallel prefetch. + * config/loongarch/loongarch.cc (loongarch_option_override_internal): + Set up parameters to be used in prefetching algorithm. + * config/loongarch/loongarch.md (prefetch): New template. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/constraints.md | 10 ++++++++++ + gcc/config/loongarch/loongarch-def.c | 2 ++ + gcc/config/loongarch/loongarch-tune.h | 1 + + gcc/config/loongarch/loongarch.cc | 28 +++++++++++++++++++++++++++ + gcc/config/loongarch/loongarch.md | 14 ++++++++++++++ + 5 files changed, 55 insertions(+) + +diff --git a/gcc/config/loongarch/constraints.md b/gcc/config/loongarch/constraints.md +index 43cb7b5f0..46f7f63ae 100644 +--- a/gcc/config/loongarch/constraints.md ++++ b/gcc/config/loongarch/constraints.md +@@ -86,6 +86,10 @@ + ;; "ZB" + ;; "An address that is held in a general-purpose register. + ;; The offset is zero" ++;; "ZD" ++;; "An address operand whose address is formed by a base register ++;; and offset that is suitable for use in instructions with the same ++;; addressing mode as @code{preld}." + ;; "<" "Matches a pre-dec or post-dec operand." (Global non-architectural) + ;; ">" "Matches a pre-inc or post-inc operand." (Global non-architectural) + +@@ -190,3 +194,9 @@ + The offset is zero" + (and (match_code "mem") + (match_test "REG_P (XEXP (op, 0))"))) ++ ++(define_address_constraint "ZD" ++ "An address operand whose address is formed by a base register ++ and offset that is suitable for use in instructions with the same ++ addressing mode as @code{preld}." ++ (match_test "loongarch_12bit_offset_address_p (op, mode)")) +diff --git a/gcc/config/loongarch/loongarch-def.c b/gcc/config/loongarch/loongarch-def.c +index cbf995d81..80ab10a52 100644 +--- a/gcc/config/loongarch/loongarch-def.c ++++ b/gcc/config/loongarch/loongarch-def.c +@@ -62,11 +62,13 @@ loongarch_cpu_cacheN_TUNE_TYPES = { + .l1d_line_size = 64, + .l1d_size = 64, + .l2d_size = 256, ++ .simultaneous_prefetches = 4, + }, + CPU_LA464 = { + .l1d_line_size = 64, + .l1d_size = 64, + .l2d_size = 256, ++ .simultaneous_prefetches = 4, + }, + }; + +diff --git a/gcc/config/loongarch/loongarch-tune.h b/gcc/config/loongarch/loongarch-tune.h +index 6f3530f5c..8e3eb2947 100644 +--- a/gcc/config/loongarch/loongarch-tune.h ++++ b/gcc/config/loongarch/loongarch-tune.h +@@ -45,6 +45,7 @@ struct loongarch_cache { + int l1d_line_size; /* bytes */ + int l1d_size; /* KiB */ + int l2d_size; /* kiB */ ++ int simultaneous_prefetches; /* number of parallel prefetch */ + }; + + #endif /* LOONGARCH_TUNE_H */ +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index d552b162a..622c9435b 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see + #include "context.h" + #include "builtins.h" + #include "rtl-iter.h" ++#include "opts.h" + + /* This file should be included last. */ + #include "target-def.h" +@@ -6099,6 +6100,33 @@ loongarch_option_override_internal (struct gcc_options *opts) + if (loongarch_branch_cost == 0) + loongarch_branch_cost = loongarch_cost->branch_cost; + ++ /* Set up parameters to be used in prefetching algorithm. */ ++ int simultaneous_prefetches ++ = loongarch_cpu_cacheLARCH_ACTUAL_TUNE.simultaneous_prefetches; ++ ++ SET_OPTION_IF_UNSET (opts, &global_options_set, ++ param_simultaneous_prefetches, ++ simultaneous_prefetches); ++ ++ SET_OPTION_IF_UNSET (opts, &global_options_set, ++ param_l1_cache_line_size, ++ loongarch_cpu_cacheLARCH_ACTUAL_TUNE.l1d_line_size); ++ ++ SET_OPTION_IF_UNSET (opts, &global_options_set, ++ param_l1_cache_size, ++ loongarch_cpu_cacheLARCH_ACTUAL_TUNE.l1d_size); ++ ++ SET_OPTION_IF_UNSET (opts, &global_options_set, ++ param_l2_cache_size, ++ loongarch_cpu_cacheLARCH_ACTUAL_TUNE.l2d_size); ++ ++ ++ /* Enable sw prefetching at -O3 and higher. */ ++ if (opts->x_flag_prefetch_loop_arrays < 0 ++ && (opts->x_optimize >= 3 || opts->x_flag_profile_use) ++ && !opts->x_optimize_size) ++ opts->x_flag_prefetch_loop_arrays = 1; ++ + if (TARGET_DIRECT_EXTERN_ACCESS && flag_shlib) + error ("%qs cannot be used for compiling a shared library", + "-mdirect-extern-access"); +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 682ab9617..2fda53819 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -3282,6 +3282,20 @@ + ;; .................... + ;; + ++(define_insn "prefetch" ++ (prefetch (match_operand 0 "address_operand" "ZD") ++ (match_operand 1 "const_int_operand" "n") ++ (match_operand 2 "const_int_operand" "n")) ++ "" ++{ ++ switch (INTVAL (operands1)) ++ { ++ case 0: return "preld\t0,%a0"; ++ case 1: return "preld\t8,%a0"; ++ default: gcc_unreachable (); ++ } ++}) ++ + (define_insn "nop" + (const_int 0) + "" +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-support-code-model-extreme.patch
Added
@@ -0,0 +1,794 @@ +From b1c92fb9dab678e4c9c23fa77185011494d145b9 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 18 Aug 2022 17:26:13 +0800 +Subject: PATCH 011/124 LoongArch: Add support code model extreme. + +Use five instructions to calculate a signed 64-bit offset relative to the pc. + +gcc/ChangeLog: + + * config/loongarch/loongarch-opts.cc: Allow cmodel to be extreme. + * config/loongarch/loongarch.cc (loongarch_call_tls_get_addr): + Add extreme support for TLS GD and LD types. + (loongarch_legitimize_tls_address): Add extreme support for TLS LE + and IE. + (loongarch_split_symbol): When compiling with -mcmodel=extreme, + the symbol address will be obtained through five instructions. + (loongarch_print_operand_reloc): Add support. + (loongarch_print_operand): Add support. + (loongarch_print_operand_address): Add support. + (loongarch_option_override_internal): Set '-mcmodel=extreme' option + incompatible with '-mno-explicit-relocs'. + * config/loongarch/loongarch.md (@lui_l_hi20<mode>): + Loads bits 12-31 of data into registers. + (lui_h_lo20): Load bits 32-51 of the data and spell bits 0-31 of + the source register. + (lui_h_hi12): Load bits 52-63 of the data and spell bits 0-51 of + the source register. + * config/loongarch/predicates.md: Symbols need to be decomposed + when defining the macro TARGET_CMODEL_EXTREME + * doc/invoke.texi: Modify the description information of cmodel in the document. + Document -Wno-extreme-plt. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/func-call-1.c: Add option '-mcmodel=normal'. + * gcc.target/loongarch/func-call-2.c: Likewise. + * gcc.target/loongarch/func-call-3.c: Likewise. + * gcc.target/loongarch/func-call-4.c: Likewise. + * gcc.target/loongarch/func-call-5.c: Likewise. + * gcc.target/loongarch/func-call-6.c: Likewise. + * gcc.target/loongarch/func-call-7.c: Likewise. + * gcc.target/loongarch/func-call-8.c: Likewise. + * gcc.target/loongarch/relocs-symbol-noaddend.c: Likewise. + * gcc.target/loongarch/func-call-extreme-1.c: New test. + * gcc.target/loongarch/func-call-extreme-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-opts.cc | 3 +- + gcc/config/loongarch/loongarch.cc | 222 +++++++++++++++--- + gcc/config/loongarch/loongarch.md | 34 ++- + gcc/config/loongarch/predicates.md | 9 +- + gcc/doc/invoke.texi | 50 +--- + .../gcc.target/loongarch/func-call-1.c | 2 +- + .../gcc.target/loongarch/func-call-2.c | 2 +- + .../gcc.target/loongarch/func-call-3.c | 2 +- + .../gcc.target/loongarch/func-call-4.c | 2 +- + .../gcc.target/loongarch/func-call-5.c | 2 +- + .../gcc.target/loongarch/func-call-6.c | 2 +- + .../gcc.target/loongarch/func-call-7.c | 2 +- + .../gcc.target/loongarch/func-call-8.c | 2 +- + .../loongarch/func-call-extreme-1.c | 32 +++ + .../loongarch/func-call-extreme-2.c | 32 +++ + .../loongarch/relocs-symbol-noaddend.c | 2 +- + 16 files changed, 318 insertions(+), 82 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-extreme-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-extreme-2.c + +diff --git a/gcc/config/loongarch/loongarch-opts.cc b/gcc/config/loongarch/loongarch-opts.cc +index 3f70943de..2ae89f234 100644 +--- a/gcc/config/loongarch/loongarch-opts.cc ++++ b/gcc/config/loongarch/loongarch-opts.cc +@@ -376,14 +376,13 @@ fallback: + + /* 5. Target code model */ + t.cmodel = constrained.cmodel ? opt_cmodel : CMODEL_NORMAL; +- if (t.cmodel != CMODEL_NORMAL) ++ if (t.cmodel != CMODEL_NORMAL && t.cmodel != CMODEL_EXTREME) + { + warning (0, "%qs is not supported, now cmodel is set to %qs", + loongarch_cmodel_stringst.cmodel, "normal"); + t.cmodel = CMODEL_NORMAL; + } + +- + /* Cleanup and return. */ + obstack_free (&msg_obstack, NULL); + *target = t; +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 76bf55ea4..1a33f668f 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -2436,7 +2436,19 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + /* Split tls symbol to high and low. */ + rtx high = gen_rtx_HIGH (Pmode, copy_rtx (loc)); + high = loongarch_force_temporary (tmp, high); +- emit_insn (gen_tls_low (Pmode, a0, high, loc)); ++ ++ if (TARGET_CMODEL_EXTREME) ++ { ++ gcc_assert (TARGET_EXPLICIT_RELOCS); ++ ++ rtx tmp1 = gen_reg_rtx (Pmode); ++ emit_insn (gen_tls_low (Pmode, tmp1, gen_rtx_REG (Pmode, 0), loc)); ++ emit_insn (gen_lui_h_lo20 (tmp1, tmp1, loc)); ++ emit_insn (gen_lui_h_hi12 (tmp1, tmp1, loc)); ++ emit_move_insn (a0, gen_rtx_PLUS (Pmode, high, tmp1)); ++ } ++ else ++ emit_insn (gen_tls_low (Pmode, a0, high, loc)); + } + else + { +@@ -2449,14 +2461,44 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + } + + if (flag_plt) +- insn = emit_call_insn (gen_call_value_internal (v0, loongarch_tls_symbol, ++ insn = emit_call_insn (gen_call_value_internal (v0, ++ loongarch_tls_symbol, + const0_rtx)); + else + { + rtx dest = gen_reg_rtx (Pmode); +- rtx high = gen_reg_rtx (Pmode); +- loongarch_emit_move (high, gen_rtx_HIGH (Pmode, loongarch_tls_symbol)); +- emit_insn (gen_ld_from_got (Pmode, dest, high, loongarch_tls_symbol)); ++ ++ if (TARGET_CMODEL_EXTREME) ++ { ++ gcc_assert (TARGET_EXPLICIT_RELOCS); ++ ++ rtx tmp1 = gen_reg_rtx (Pmode); ++ rtx high = gen_reg_rtx (Pmode); ++ ++ loongarch_emit_move (high, ++ gen_rtx_HIGH (Pmode, loongarch_tls_symbol)); ++ loongarch_emit_move (tmp1, gen_rtx_LO_SUM (Pmode, ++ gen_rtx_REG (Pmode, 0), ++ loongarch_tls_symbol)); ++ emit_insn (gen_lui_h_lo20 (tmp1, tmp1, loongarch_tls_symbol)); ++ emit_insn (gen_lui_h_hi12 (tmp1, tmp1, loongarch_tls_symbol)); ++ loongarch_emit_move (dest, ++ gen_rtx_MEM (Pmode, ++ gen_rtx_PLUS (Pmode, high, tmp1))); ++ } ++ else ++ { ++ if (TARGET_EXPLICIT_RELOCS) ++ { ++ rtx high = gen_reg_rtx (Pmode); ++ loongarch_emit_move (high, ++ gen_rtx_HIGH (Pmode, loongarch_tls_symbol)); ++ emit_insn (gen_ld_from_got (Pmode, dest, high, ++ loongarch_tls_symbol)); ++ } ++ else ++ loongarch_emit_move (dest, loongarch_tls_symbol); ++ } + insn = emit_call_insn (gen_call_value_internal (v0, dest, const0_rtx)); + } + +@@ -2508,7 +2550,23 @@ loongarch_legitimize_tls_address (rtx loc) + tmp3 = gen_reg_rtx (Pmode); + rtx high = gen_rtx_HIGH (Pmode, copy_rtx (tmp2)); + high = loongarch_force_temporary (tmp3, high); +- emit_insn (gen_ld_from_got (Pmode, tmp1, high, tmp2)); ++ ++ if (TARGET_CMODEL_EXTREME) ++ { ++ gcc_assert (TARGET_EXPLICIT_RELOCS); ++ ++ rtx tmp3 = gen_reg_rtx (Pmode); ++ emit_insn (gen_tls_low (Pmode, tmp3, ++ gen_rtx_REG (Pmode, 0), tmp2)); ++ emit_insn (gen_lui_h_lo20 (tmp3, tmp3, tmp2)); ++ emit_insn (gen_lui_h_hi12 (tmp3, tmp3, tmp2)); ++ emit_move_insn (tmp1, ++ gen_rtx_MEM (Pmode, ++ gen_rtx_PLUS (Pmode, ++ high, tmp3))); ++ } ++ else ++ emit_insn (gen_ld_from_got (Pmode, tmp1, high, tmp2)); + } + else + emit_insn (loongarch_got_load_tls_ie (tmp1, loc)); +@@ -2530,11 +2588,18 @@ loongarch_legitimize_tls_address (rtx loc) + rtx high = gen_rtx_HIGH (Pmode, copy_rtx (tmp2)); + high = loongarch_force_temporary (tmp3, high); + emit_insn (gen_ori_l_lo12 (Pmode, tmp1, high, tmp2)); ++ ++ if (TARGET_CMODEL_EXTREME) ++ { ++ gcc_assert (TARGET_EXPLICIT_RELOCS); ++ ++ emit_insn (gen_lui_h_lo20 (tmp1, tmp1, tmp2)); ++ emit_insn (gen_lui_h_hi12 (tmp1, tmp1, tmp2)); ++ } + } + else + emit_insn (loongarch_got_load_tls_le (tmp1, loc)); + emit_insn (gen_add3_insn (dest, tmp1, tp)); +- + } + break; + +@@ -2603,7 +2668,6 @@ bool + loongarch_split_symbol (rtx temp, rtx addr, machine_mode mode, rtx *low_out) + { + enum loongarch_symbol_type symbol_type; +- rtx high; + + /* If build with '-mno-explicit-relocs', don't split symbol. */ + if (!TARGET_EXPLICIT_RELOCS) +@@ -2615,6 +2679,8 @@ loongarch_split_symbol (rtx temp, rtx addr, machine_mode mode, rtx *low_out) + || !loongarch_split_symbol_type (symbol_type)) + return false; + ++ rtx high, temp1 = NULL; ++ + if (temp == NULL) + temp = gen_reg_rtx (Pmode); + +@@ -2622,20 +2688,42 @@ loongarch_split_symbol (rtx temp, rtx addr, machine_mode mode, rtx *low_out) + high = gen_rtx_HIGH (Pmode, copy_rtx (addr)); + high = loongarch_force_temporary (temp, high); + ++ if (TARGET_CMODEL_EXTREME && can_create_pseudo_p ()) ++ { ++ gcc_assert (TARGET_EXPLICIT_RELOCS); ++ ++ temp1 = gen_reg_rtx (Pmode); ++ emit_move_insn (temp1, gen_rtx_LO_SUM (Pmode, gen_rtx_REG (Pmode, 0), ++ addr)); ++ emit_insn (gen_lui_h_lo20 (temp1, temp1, addr)); ++ emit_insn (gen_lui_h_hi12 (temp1, temp1, addr)); ++ } ++ + if (low_out) + switch (symbol_type) + { + case SYMBOL_PCREL: +- *low_out = gen_rtx_LO_SUM (Pmode, high, addr); +- break; ++ { ++ if (TARGET_CMODEL_EXTREME && can_create_pseudo_p ()) ++ *low_out = gen_rtx_PLUS (Pmode, high, temp1); ++ else ++ *low_out = gen_rtx_LO_SUM (Pmode, high, addr); ++ break; ++ } + + case SYMBOL_GOT_DISP: + /* SYMBOL_GOT_DISP symbols are loaded from the GOT. */ + { +- rtx low = gen_rtx_LO_SUM (Pmode, high, addr); +- rtx mem = gen_rtx_MEM (Pmode, low); +- *low_out = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, mem), +- UNSPEC_LOAD_FROM_GOT); ++ if (TARGET_CMODEL_EXTREME && can_create_pseudo_p ()) ++ *low_out = gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, high, temp1)); ++ else ++ { ++ rtx low = gen_rtx_LO_SUM (Pmode, high, addr); ++ rtx mem = gen_rtx_MEM (Pmode, low); ++ *low_out = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, mem), ++ UNSPEC_LOAD_FROM_GOT); ++ } ++ + break; + } + +@@ -4584,34 +4672,86 @@ loongarch_memmodel_needs_release_fence (enum memmodel model) + in context CONTEXT. HI_RELOC indicates a high-part reloc. */ + + static void +-loongarch_print_operand_reloc (FILE *file, rtx op, bool hi_reloc) ++loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part, ++ bool hi_reloc) + { + const char *reloc; + ++ if (TARGET_CMODEL_EXTREME) ++ gcc_assert (TARGET_EXPLICIT_RELOCS); ++ + switch (loongarch_classify_symbolic_expression (op)) + { + case SYMBOL_PCREL: +- reloc = hi_reloc ? "%pc_hi20" : "%pc_lo12"; ++ if (hi64_part) ++ { ++ if (TARGET_CMODEL_EXTREME) ++ reloc = hi_reloc ? "%pc64_hi12" : "%pc64_lo20"; ++ else ++ gcc_unreachable (); ++ } ++ else ++ reloc = hi_reloc ? "%pc_hi20" : "%pc_lo12"; + break; + + case SYMBOL_GOT_DISP: +- reloc = hi_reloc ? "%got_pc_hi20" : "%got_pc_lo12"; ++ if (hi64_part) ++ { ++ if (TARGET_CMODEL_EXTREME) ++ reloc = hi_reloc ? "%got64_pc_hi12" : "%got64_pc_lo20"; ++ else ++ gcc_unreachable (); ++ } ++ else ++ reloc = hi_reloc ? "%got_pc_hi20" : "%got_pc_lo12"; + break; + + case SYMBOL_TLS_IE: +- reloc = hi_reloc ? "%ie_pc_hi20" : "%ie_pc_lo12"; ++ if (hi64_part) ++ { ++ if (TARGET_CMODEL_EXTREME) ++ reloc = hi_reloc ? "%ie64_pc_hi12" : "%ie64_pc_lo20"; ++ else ++ gcc_unreachable (); ++ } ++ else ++ reloc = hi_reloc ? "%ie_pc_hi20" : "%ie_pc_lo12"; + break; + + case SYMBOL_TLS_LE: +- reloc = hi_reloc ? "%le_hi20" : "%le_lo12"; ++ if (hi64_part) ++ { ++ if (TARGET_CMODEL_EXTREME) ++ reloc = hi_reloc ? "%le64_hi12" : "%le64_lo20"; ++ else ++ gcc_unreachable (); ++ } ++ else ++ reloc = hi_reloc ? "%le_hi20" : "%le_lo12"; + break; + + case SYMBOL_TLSGD: +- reloc = hi_reloc ? "%gd_pc_hi20" : "%got_pc_lo12"; ++ if (hi64_part) ++ { ++ if (TARGET_CMODEL_EXTREME) ++ reloc = hi_reloc ? "%got64_pc_hi12" : "%got64_pc_lo20"; ++ else ++ gcc_unreachable (); ++ } ++ else ++ reloc = hi_reloc ? "%gd_pc_hi20" : "%got_pc_lo12"; + break; + + case SYMBOL_TLSLDM: +- reloc = hi_reloc ? "%ld_pc_hi20" : "%got_pc_lo12"; ++ if (hi64_part) ++ { ++ if (TARGET_CMODEL_EXTREME) ++ reloc = hi_reloc ? "%got64_pc_hi12" : "%got64_pc_lo20"; ++ else ++ gcc_unreachable (); ++ } ++ else ++ reloc = hi_reloc ? "%ld_pc_hi20" : "%got_pc_lo12"; + break; + + default: +@@ -4637,6 +4777,8 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi_reloc) + 'L' Print the low-part relocation associated with OP. + 'm' Print one less than CONST_INT OP in decimal. + 'N' Print the inverse of the integer branch condition for comparison OP. ++ 'r' Print address 12-31bit relocation associated with OP. ++ 'R' Print address 32-51bit relocation associated with OP. + 'T' Print 'f' for (eq:CC ...), 't' for (ne:CC ...), + 'z' for (eq:?I ...), 'n' for (ne:?I ...). + 't' Like 'T', but with the EQ/NE cases reversed +@@ -4694,7 +4836,13 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + case 'h': + if (code == HIGH) + op = XEXP (op, 0); +- loongarch_print_operand_reloc (file, op, true /* hi_reloc */); ++ loongarch_print_operand_reloc (file, op, false /* hi64_part */, ++ true /* hi_reloc */); ++ break; ++ ++ case 'H': ++ loongarch_print_operand_reloc (file, op, true /* hi64_part */, ++ true /* hi_reloc */); + break; + + case 'i': +@@ -4703,7 +4851,8 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + break; + + case 'L': +- loongarch_print_operand_reloc (file, op, false /* lo_reloc */); ++ loongarch_print_operand_reloc (file, op, false /* hi64_part*/, ++ false /* lo_reloc */); + break; + + case 'm': +@@ -4718,6 +4867,16 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + letter); + break; + ++ case 'r': ++ loongarch_print_operand_reloc (file, op, false /* hi64_part */, ++ true /* lo_reloc */); ++ break; ++ ++ case 'R': ++ loongarch_print_operand_reloc (file, op, true /* hi64_part */, ++ false /* lo_reloc */); ++ break; ++ + case 't': + case 'T': + { +@@ -4848,7 +5007,8 @@ loongarch_print_operand_address (FILE *file, machine_mode /* mode */, rtx x) + + case ADDRESS_LO_SUM: + fprintf (file, "%s,", reg_namesREGNO (addr.reg)); +- loongarch_print_operand_reloc (file, addr.offset, false /* hi_reloc */); ++ loongarch_print_operand_reloc (file, addr.offset, false /* hi64_part */, ++ false /* hi_reloc */); + return; + + case ADDRESS_CONST_INT: +@@ -5821,13 +5981,21 @@ loongarch_option_override_internal (struct gcc_options *opts) + + switch (la_target.cmodel) + { +- case CMODEL_TINY_STATIC: + case CMODEL_EXTREME: ++ if (!TARGET_EXPLICIT_RELOCS) ++ error ("code model %qs needs %s", ++ "extreme", "-mexplicit-relocs"); ++ + if (opts->x_flag_plt) +- error ("code model %qs and %qs not support %s mode", +- "tiny-static", "extreme", "plt"); ++ { ++ if (global_options_set.x_flag_plt) ++ error ("code model %qs is not compatible with %s", ++ "extreme", "-fplt"); ++ opts->x_flag_plt = 0; ++ } + break; + ++ case CMODEL_TINY_STATIC: + case CMODEL_NORMAL: + case CMODEL_TINY: + case CMODEL_LARGE: +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 8e8868de9..8fc10444c 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -60,6 +60,9 @@ + + UNSPEC_LOAD_FROM_GOT + UNSPEC_ORI_L_LO12 ++ UNSPEC_LUI_L_HI20 ++ UNSPEC_LUI_H_LO20 ++ UNSPEC_LUI_H_HI12 + UNSPEC_TLS_LOW + ) + +@@ -1934,16 +1937,45 @@ + (set_attr "type" "move") + ) + ++(define_insn "@lui_l_hi20<mode>" ++ (set (match_operand:P 0 "register_operand" "=r") ++ (unspec:P (match_operand:P 1 "symbolic_operand") ++ UNSPEC_LUI_L_HI20)) ++ "" ++ "lu12i.w\t%0,%r1" ++ (set_attr "type" "move") ++) ++ + (define_insn "@ori_l_lo12<mode>" + (set (match_operand:P 0 "register_operand" "=r") + (unspec:P (match_operand:P 1 "register_operand" "r") +- (match_operand:P 2 "symbolic_operand") ++ (match_operand:P 2 "symbolic_operand") + UNSPEC_ORI_L_LO12)) + "" + "ori\t%0,%1,%L2" + (set_attr "type" "move") + ) + ++(define_insn "lui_h_lo20" ++ (set (match_operand:DI 0 "register_operand" "=r") ++ (unspec:DI (match_operand:DI 1 "register_operand" "0") ++ (match_operand:DI 2 "symbolic_operand") ++ UNSPEC_LUI_H_LO20)) ++ "TARGET_64BIT" ++ "lu32i.d\t%0,%R2" ++ (set_attr "type" "move") ++) ++ ++(define_insn "lui_h_hi12" ++ (set (match_operand:DI 0 "register_operand" "=r") ++ (unspec:DI (match_operand:DI 1 "register_operand" "r") ++ (match_operand:DI 2 "symbolic_operand") ++ UNSPEC_LUI_H_HI12)) ++ "TARGET_64BIT" ++ "lu52i.d\t%0,%1,%H2" ++ (set_attr "type" "move") ++) ++ + ;; Convert floating-point numbers to integers + (define_insn "frint_<fmt>" + (set (match_operand:ANYF 0 "register_operand" "=f") +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index cd3528c7c..e38c6fbdd 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -111,7 +111,7 @@ + (match_code "const,symbol_ref,label_ref") + { + /* Split symbol to high and low if return false. +- If defined TARGET_CMODEL_LARGE, all symbol would be splited, ++ If defined TARGET_CMODEL_EXTREME, all symbol would be splited, + else if offset is not zero, the symbol would be splited. */ + + enum loongarch_symbol_type symbol_type; +@@ -126,10 +126,13 @@ + switch (symbol_type) + { + case SYMBOL_PCREL: +- return 1; ++ if (TARGET_CMODEL_EXTREME) ++ return false; ++ else ++ return 1; + + case SYMBOL_GOT_DISP: +- if (TARGET_CMODEL_LARGE || !flag_plt) ++ if (TARGET_CMODEL_EXTREME || !flag_plt) + return false; + else + return 1; +diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi +index 1de2b2bd4..c4f83e62a 100644 +--- a/gcc/doc/invoke.texi ++++ b/gcc/doc/invoke.texi +@@ -1006,6 +1006,7 @@ Objective-C and Objective-C++ Dialects}. + -mcond-move-float -mno-cond-move-float @gol + -memcpy -mno-memcpy -mstrict-align -mno-strict-align @gol + -mmax-inline-memcpy-size=@var{n} @gol ++-mexplicit-relocs -mno-explicit-relocs @gol + -mcmodel=@var{code-model}} + + @emph{M32R/D Options} +@@ -24617,50 +24618,19 @@ less than or equal to @var{n} bytes. The default value of @var{n} is 1024. + @item -mcmodel=@var{code-model} + Set the code model to one of: + @table @samp +-@item tiny-static +-@itemize @bullet +-@item +-local symbol and global strong symbol: The data section must be within +/-2MiB addressing space. +-The text section must be within +/-128MiB addressing space. +-@item +-global weak symbol: The got table must be within +/-2GiB addressing space. +-@end itemize +- +-@item tiny +-@itemize @bullet +-@item +-local symbol: The data section must be within +/-2MiB addressing space. +-The text section must be within +/-128MiB +-addressing space. +-@item +-global symbol: The got table must be within +/-2GiB addressing space. +-@end itemize ++@item tiny-static (Not implemented yet) ++@item tiny (Not implemented yet) + + @item normal +-@itemize @bullet +-@item +-local symbol: The data section must be within +/-2GiB addressing space. +-The text section must be within +/-128MiB addressing space. +-@item +-global symbol: The got table must be within +/-2GiB addressing space. +-@end itemize ++The text segment must be within 128MB addressing space. The data segment must ++be within 2GB addressing space. + +-@item large +-@itemize @bullet +-@item +-local symbol: The data section must be within +/-2GiB addressing space. +-The text section must be within +/-128GiB addressing space. +-@item +-global symbol: The got table must be within +/-2GiB addressing space. +-@end itemize ++@item large (Not implemented yet) + +-@item extreme(Not implemented yet) +-@itemize @bullet +-@item +-local symbol: The data and text section must be within +/-8EiB addressing space. +-@item +-global symbol: The data got table must be within +/-8EiB addressing space. +-@end itemize ++@item extreme ++This mode does not limit the size of the code segment and data segment. ++The @option{-mcmodel=extreme} option is incompatible with @option{-fplt} and ++@option{-mno-explicit-relocs}. + @end table + The default code model is @code{normal}. + +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-1.c b/gcc/testsuite/gcc.target/loongarch/func-call-1.c +index 01b8ea23f..76bf11b0c 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-1.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-1.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mno-explicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mno-explicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ + /* { dg-final { scan-assembler "test1:.*bl\t%plt\\(f\\)\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-2.c b/gcc/testsuite/gcc.target/loongarch/func-call-2.c +index 4565baaec..4b468fef8 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-2.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-2.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mno-explicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mno-explicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ + /* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-3.c b/gcc/testsuite/gcc.target/loongarch/func-call-3.c +index 4f669a029..dd3a4882d 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-3.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-3.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mno-explicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mno-explicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*la\.global\t.*f\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-4.c b/gcc/testsuite/gcc.target/loongarch/func-call-4.c +index 943adb640..f8158ec34 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-4.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-4.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mno-explicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mno-explicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-5.c b/gcc/testsuite/gcc.target/loongarch/func-call-5.c +index 2c2a1c8a1..37994af43 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-5.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-5.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mexplicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mexplicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ + /* { dg-final { scan-assembler "test1:.*bl\t%plt\\(f\\)\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-6.c b/gcc/testsuite/gcc.target/loongarch/func-call-6.c +index 4b0e4266e..8e366e376 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-6.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-6.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mexplicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mexplicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ + /* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-7.c b/gcc/testsuite/gcc.target/loongarch/func-call-7.c +index 51792711f..4177c3d96 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-7.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-7.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mexplicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mexplicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%got_pc_hi20\\(f\\)\n\tld\.d\t.*%got_pc_lo12\\(f\\)\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-8.c b/gcc/testsuite/gcc.target/loongarch/func-call-8.c +index 330140d88..4254eaa16 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-8.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-8.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mexplicit-relocs" } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mexplicit-relocs -mcmodel=normal" } */ + /* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-extreme-1.c b/gcc/testsuite/gcc.target/loongarch/func-call-extreme-1.c +new file mode 100644 +index 000000000..db1e0f853 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-extreme-1.c +@@ -0,0 +1,32 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mexplicit-relocs -mcmodel=extreme" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i.*%got_pc_hi20.*\n\taddi\.d.*%got_pc_lo12.*\n\tlu32i\.d.*%got64_pc_lo20.*\n\tlu52i\.d.*%got64_pc_hi12.*\n\tldx\.d" } } */ ++/* { dg-final { scan-assembler "test1:.*pcalau12i.*%pc_hi20.*\n\taddi\.d.*%pc_lo12.*\n\tlu32i\.d.*%pc64_lo20.*\n\tlu52i\.d.*pc64_hi12.*\n\tadd\.d" } } */ ++/* { dg-final { scan-assembler "test2:.*pcalau12i.*%pc_hi20.*\n\taddi\.d.*%pc_lo12.*\n\tlu32i\.d.*%pc64_lo20.*\n\tlu52i\.d.*pc64_hi12.*\n\tadd\.d" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-extreme-2.c b/gcc/testsuite/gcc.target/loongarch/func-call-extreme-2.c +new file mode 100644 +index 000000000..21bf81ae8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-extreme-2.c +@@ -0,0 +1,32 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mexplicit-relocs -mcmodel=extreme" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i.*%got_pc_hi20.*\n\taddi\.d.*%got_pc_lo12.*\n\tlu32i\.d.*%got64_pc_lo20.*\n\tlu52i\.d.*%got64_pc_hi12.*\n\tldx\.d" } } */ ++/* { dg-final { scan-assembler "test1:.*pcalau12i.*%got_pc_hi20.*\n\taddi\.d.*%got_pc_lo12.*\n\tlu32i\.d.*%got64_pc_lo20.*\n\tlu52i\.d.*%got64_pc_hi12.*\n\tldx\.d" } } */ ++/* { dg-final { scan-assembler "test2:.*pcalau12i.*%pc_hi20.*\n\taddi\.d.*%pc_lo12.*\n\tlu32i\.d.*%pc64_lo20.*\n\tlu52i\.d.*pc64_hi12.*\n\tadd\.d" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c b/gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c +index bfcc9bc33..3ec8bd229 100644 +--- a/gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c ++++ b/gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -mexplicit-relocs -fno-pic -O2" } */ ++/* { dg-options "-mabi=lp64d -mexplicit-relocs -fno-pic -O2 -mcmodel=normal" } */ + /* { dg-final { scan-assembler "pcalau12i.*%pc_hi20\\(\.LANCHOR0\\)\n" } } */ + /* { dg-final { scan-assembler "addi\.d.*%pc_lo12\\(\.LANCHOR0\\)\n" } } */ + /* { dg-final { scan-assembler "ldptr.d\t\\\$r4,.*,0\n" } } */ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-builtin-functions.patch
Added
@@ -0,0 +1,4485 @@ +From fcf63744c4ceaa60cd57ab3c431ec63f690189d4 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:59:47 +0800 +Subject: PATCH 109/124 LoongArch: Add tests for ASX builtin functions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-builtin.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-builtin.c | 4460 +++++++++++++++++ + 1 file changed, 4460 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-builtin.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-builtin.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-builtin.c +new file mode 100644 +index 000000000..b1a903b4a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-builtin.c +@@ -0,0 +1,4460 @@ ++/* Test builtins for LOONGARCH LASX ASE instructions */ ++/* { dg-do compile } */ ++/* { dg-options "-mlasx" } */ ++/* { dg-final { scan-assembler-times "lasx_xvsll_b:.*xvsll\\.b.*lasx_xvsll_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsll_h:.*xvsll\\.h.*lasx_xvsll_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsll_w:.*xvsll\\.w.*lasx_xvsll_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsll_d:.*xvsll\\.d.*lasx_xvsll_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslli_b:.*xvslli\\.b.*lasx_xvslli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslli_h:.*xvslli\\.h.*lasx_xvslli_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslli_w:.*xvslli\\.w.*lasx_xvslli_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslli_d:.*xvslli\\.d.*lasx_xvslli_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsra_b:.*xvsra\\.b.*lasx_xvsra_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsra_h:.*xvsra\\.h.*lasx_xvsra_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsra_w:.*xvsra\\.w.*lasx_xvsra_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsra_d:.*xvsra\\.d.*lasx_xvsra_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrai_b:.*xvsrai\\.b.*lasx_xvsrai_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrai_h:.*xvsrai\\.h.*lasx_xvsrai_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrai_w:.*xvsrai\\.w.*lasx_xvsrai_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrai_d:.*xvsrai\\.d.*lasx_xvsrai_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrar_b:.*xvsrar\\.b.*lasx_xvsrar_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrar_h:.*xvsrar\\.h.*lasx_xvsrar_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrar_w:.*xvsrar\\.w.*lasx_xvsrar_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrar_d:.*xvsrar\\.d.*lasx_xvsrar_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrari_b:.*xvsrari\\.b.*lasx_xvsrari_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrari_h:.*xvsrari\\.h.*lasx_xvsrari_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrari_w:.*xvsrari\\.w.*lasx_xvsrari_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrari_d:.*xvsrari\\.d.*lasx_xvsrari_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrl_b:.*xvsrl\\.b.*lasx_xvsrl_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrl_h:.*xvsrl\\.h.*lasx_xvsrl_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrl_w:.*xvsrl\\.w.*lasx_xvsrl_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrl_d:.*xvsrl\\.d.*lasx_xvsrl_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrli_b:.*xvsrli\\.b.*lasx_xvsrli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrli_h:.*xvsrli\\.h.*lasx_xvsrli_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrli_w:.*xvsrli\\.w.*lasx_xvsrli_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrli_d:.*xvsrli\\.d.*lasx_xvsrli_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlr_b:.*xvsrlr\\.b.*lasx_xvsrlr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlr_h:.*xvsrlr\\.h.*lasx_xvsrlr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlr_w:.*xvsrlr\\.w.*lasx_xvsrlr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlr_d:.*xvsrlr\\.d.*lasx_xvsrlr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlri_b:.*xvsrlri\\.b.*lasx_xvsrlri_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlri_h:.*xvsrlri\\.h.*lasx_xvsrlri_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlri_w:.*xvsrlri\\.w.*lasx_xvsrlri_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlri_d:.*xvsrlri\\.d.*lasx_xvsrlri_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclr_b:.*xvbitclr\\.b.*lasx_xvbitclr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclr_h:.*xvbitclr\\.h.*lasx_xvbitclr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclr_w:.*xvbitclr\\.w.*lasx_xvbitclr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclr_d:.*xvbitclr\\.d.*lasx_xvbitclr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclri_b:.*xvbitclri\\.b.*lasx_xvbitclri_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclri_h:.*xvbitclri\\.h.*lasx_xvbitclri_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclri_w:.*xvbitclri\\.w.*lasx_xvbitclri_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitclri_d:.*xvbitclri\\.d.*lasx_xvbitclri_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitset_b:.*xvbitset\\.b.*lasx_xvbitset_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitset_h:.*xvbitset\\.h.*lasx_xvbitset_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitset_w:.*xvbitset\\.w.*lasx_xvbitset_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitset_d:.*xvbitset\\.d.*lasx_xvbitset_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitseti_b:.*xvbitseti\\.b.*lasx_xvbitseti_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitseti_h:.*xvbitseti\\.h.*lasx_xvbitseti_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitseti_w:.*xvbitseti\\.w.*lasx_xvbitseti_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitseti_d:.*xvbitseti\\.d.*lasx_xvbitseti_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrev_b:.*xvbitrev\\.b.*lasx_xvbitrev_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrev_h:.*xvbitrev\\.h.*lasx_xvbitrev_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrev_w:.*xvbitrev\\.w.*lasx_xvbitrev_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrev_d:.*xvbitrev\\.d.*lasx_xvbitrev_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrevi_b:.*xvbitrevi\\.b.*lasx_xvbitrevi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrevi_h:.*xvbitrevi\\.h.*lasx_xvbitrevi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrevi_w:.*xvbitrevi\\.w.*lasx_xvbitrevi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitrevi_d:.*xvbitrevi\\.d.*lasx_xvbitrevi_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadd_b:.*xvadd\\.b.*lasx_xvadd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadd_h:.*xvadd\\.h.*lasx_xvadd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadd_w:.*xvadd\\.w.*lasx_xvadd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadd_d:.*xvadd\\.d.*lasx_xvadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddi_bu:.*xvaddi\\.bu.*lasx_xvaddi_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddi_hu:.*xvaddi\\.hu.*lasx_xvaddi_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddi_wu:.*xvaddi\\.wu.*lasx_xvaddi_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddi_du:.*xvaddi\\.du.*lasx_xvaddi_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsub_b:.*xvsub\\.b.*lasx_xvsub_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsub_h:.*xvsub\\.h.*lasx_xvsub_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsub_w:.*xvsub\\.w.*lasx_xvsub_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsub_d:.*xvsub\\.d.*lasx_xvsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubi_bu:.*xvsubi\\.bu.*lasx_xvsubi_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubi_hu:.*xvsubi\\.hu.*lasx_xvsubi_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubi_wu:.*xvsubi\\.wu.*lasx_xvsubi_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubi_du:.*xvsubi\\.du.*lasx_xvsubi_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_b:.*xvmax\\.b.*lasx_xvmax_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_h:.*xvmax\\.h.*lasx_xvmax_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_w:.*xvmax\\.w.*lasx_xvmax_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_d:.*xvmax\\.d.*lasx_xvmax_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_b:.*xvmaxi\\.b.*lasx_xvmaxi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_h:.*xvmaxi\\.h.*lasx_xvmaxi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_w:.*xvmaxi\\.w.*lasx_xvmaxi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_d:.*xvmaxi\\.d.*lasx_xvmaxi_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_bu:.*xvmax\\.bu.*lasx_xvmax_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_hu:.*xvmax\\.hu.*lasx_xvmax_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_wu:.*xvmax\\.wu.*lasx_xvmax_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmax_du:.*xvmax\\.du.*lasx_xvmax_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_bu:.*xvmaxi\\.bu.*lasx_xvmaxi_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_hu:.*xvmaxi\\.hu.*lasx_xvmaxi_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_wu:.*xvmaxi\\.wu.*lasx_xvmaxi_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaxi_du:.*xvmaxi\\.du.*lasx_xvmaxi_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_b:.*xvmin\\.b.*lasx_xvmin_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_h:.*xvmin\\.h.*lasx_xvmin_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_w:.*xvmin\\.w.*lasx_xvmin_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_d:.*xvmin\\.d.*lasx_xvmin_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_b:.*xvmini\\.b.*lasx_xvmini_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_h:.*xvmini\\.h.*lasx_xvmini_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_w:.*xvmini\\.w.*lasx_xvmini_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_d:.*xvmini\\.d.*lasx_xvmini_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_bu:.*xvmin\\.bu.*lasx_xvmin_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_hu:.*xvmin\\.hu.*lasx_xvmin_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_wu:.*xvmin\\.wu.*lasx_xvmin_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmin_du:.*xvmin\\.du.*lasx_xvmin_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_bu:.*xvmini\\.bu.*lasx_xvmini_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_hu:.*xvmini\\.hu.*lasx_xvmini_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_wu:.*xvmini\\.wu.*lasx_xvmini_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmini_du:.*xvmini\\.du.*lasx_xvmini_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseq_b:.*xvseq\\.b.*lasx_xvseq_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseq_h:.*xvseq\\.h.*lasx_xvseq_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseq_w:.*xvseq\\.w.*lasx_xvseq_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseq_d:.*xvseq\\.d.*lasx_xvseq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseqi_b:.*xvseqi\\.b.*lasx_xvseqi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseqi_h:.*xvseqi\\.h.*lasx_xvseqi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseqi_w:.*xvseqi\\.w.*lasx_xvseqi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvseqi_d:.*xvseqi\\.d.*lasx_xvseqi_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_b:.*xvslt\\.b.*lasx_xvslt_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_h:.*xvslt\\.h.*lasx_xvslt_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_w:.*xvslt\\.w.*lasx_xvslt_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_d:.*xvslt\\.d.*lasx_xvslt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_b:.*xvslti\\.b.*lasx_xvslti_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_h:.*xvslti\\.h.*lasx_xvslti_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_w:.*xvslti\\.w.*lasx_xvslti_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_d:.*xvslti\\.d.*lasx_xvslti_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_bu:.*xvslt\\.bu.*lasx_xvslt_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_hu:.*xvslt\\.hu.*lasx_xvslt_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_wu:.*xvslt\\.wu.*lasx_xvslt_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslt_du:.*xvslt\\.du.*lasx_xvslt_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_bu:.*xvslti\\.bu.*lasx_xvslti_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_hu:.*xvslti\\.hu.*lasx_xvslti_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_wu:.*xvslti\\.wu.*lasx_xvslti_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslti_du:.*xvslti\\.du.*lasx_xvslti_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_b:.*xvsle\\.b.*lasx_xvsle_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_h:.*xvsle\\.h.*lasx_xvsle_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_w:.*xvsle\\.w.*lasx_xvsle_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_d:.*xvsle\\.d.*lasx_xvsle_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_b:.*xvslei\\.b.*lasx_xvslei_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_h:.*xvslei\\.h.*lasx_xvslei_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_w:.*xvslei\\.w.*lasx_xvslei_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_d:.*xvslei\\.d.*lasx_xvslei_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_bu:.*xvsle\\.bu.*lasx_xvsle_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_hu:.*xvsle\\.hu.*lasx_xvsle_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_wu:.*xvsle\\.wu.*lasx_xvsle_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsle_du:.*xvsle\\.du.*lasx_xvsle_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_bu:.*xvslei\\.bu.*lasx_xvslei_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_hu:.*xvslei\\.hu.*lasx_xvslei_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_wu:.*xvslei\\.wu.*lasx_xvslei_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvslei_du:.*xvslei\\.du.*lasx_xvslei_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_b:.*xvsat\\.b.*lasx_xvsat_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_h:.*xvsat\\.h.*lasx_xvsat_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_w:.*xvsat\\.w.*lasx_xvsat_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_d:.*xvsat\\.d.*lasx_xvsat_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_bu:.*xvsat\\.bu.*lasx_xvsat_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_hu:.*xvsat\\.hu.*lasx_xvsat_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_wu:.*xvsat\\.wu.*lasx_xvsat_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsat_du:.*xvsat\\.du.*lasx_xvsat_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadda_b:.*xvadda\\.b.*lasx_xvadda_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadda_h:.*xvadda\\.h.*lasx_xvadda_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadda_w:.*xvadda\\.w.*lasx_xvadda_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadda_d:.*xvadda\\.d.*lasx_xvadda_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_b:.*xvsadd\\.b.*lasx_xvsadd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_h:.*xvsadd\\.h.*lasx_xvsadd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_w:.*xvsadd\\.w.*lasx_xvsadd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_d:.*xvsadd\\.d.*lasx_xvsadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_bu:.*xvsadd\\.bu.*lasx_xvsadd_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_hu:.*xvsadd\\.hu.*lasx_xvsadd_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_wu:.*xvsadd\\.wu.*lasx_xvsadd_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsadd_du:.*xvsadd\\.du.*lasx_xvsadd_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_b:.*xvavg\\.b.*lasx_xvavg_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_h:.*xvavg\\.h.*lasx_xvavg_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_w:.*xvavg\\.w.*lasx_xvavg_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_d:.*xvavg\\.d.*lasx_xvavg_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_bu:.*xvavg\\.bu.*lasx_xvavg_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_hu:.*xvavg\\.hu.*lasx_xvavg_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_wu:.*xvavg\\.wu.*lasx_xvavg_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavg_du:.*xvavg\\.du.*lasx_xvavg_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_b:.*xvavgr\\.b.*lasx_xvavgr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_h:.*xvavgr\\.h.*lasx_xvavgr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_w:.*xvavgr\\.w.*lasx_xvavgr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_d:.*xvavgr\\.d.*lasx_xvavgr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_bu:.*xvavgr\\.bu.*lasx_xvavgr_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_hu:.*xvavgr\\.hu.*lasx_xvavgr_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_wu:.*xvavgr\\.wu.*lasx_xvavgr_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvavgr_du:.*xvavgr\\.du.*lasx_xvavgr_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_b:.*xvssub\\.b.*lasx_xvssub_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_h:.*xvssub\\.h.*lasx_xvssub_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_w:.*xvssub\\.w.*lasx_xvssub_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_d:.*xvssub\\.d.*lasx_xvssub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_bu:.*xvssub\\.bu.*lasx_xvssub_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_hu:.*xvssub\\.hu.*lasx_xvssub_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_wu:.*xvssub\\.wu.*lasx_xvssub_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssub_du:.*xvssub\\.du.*lasx_xvssub_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_b:.*xvabsd\\.b.*lasx_xvabsd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_h:.*xvabsd\\.h.*lasx_xvabsd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_w:.*xvabsd\\.w.*lasx_xvabsd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_d:.*xvabsd\\.d.*lasx_xvabsd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_bu:.*xvabsd\\.bu.*lasx_xvabsd_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_hu:.*xvabsd\\.hu.*lasx_xvabsd_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_wu:.*xvabsd\\.wu.*lasx_xvabsd_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvabsd_du:.*xvabsd\\.du.*lasx_xvabsd_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmul_b:.*xvmul\\.b.*lasx_xvmul_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmul_h:.*xvmul\\.h.*lasx_xvmul_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmul_w:.*xvmul\\.w.*lasx_xvmul_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmul_d:.*xvmul\\.d.*lasx_xvmul_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmadd_b:.*xvmadd\\.b.*lasx_xvmadd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmadd_h:.*xvmadd\\.h.*lasx_xvmadd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmadd_w:.*xvmadd\\.w.*lasx_xvmadd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmadd_d:.*xvmadd\\.d.*lasx_xvmadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmsub_b:.*xvmsub\\.b.*lasx_xvmsub_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmsub_h:.*xvmsub\\.h.*lasx_xvmsub_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmsub_w:.*xvmsub\\.w.*lasx_xvmsub_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmsub_d:.*xvmsub\\.d.*lasx_xvmsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_b:.*xvdiv\\.b.*lasx_xvdiv_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_h:.*xvdiv\\.h.*lasx_xvdiv_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_w:.*xvdiv\\.w.*lasx_xvdiv_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_d:.*xvdiv\\.d.*lasx_xvdiv_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_bu:.*xvdiv\\.bu.*lasx_xvdiv_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_hu:.*xvdiv\\.hu.*lasx_xvdiv_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_wu:.*xvdiv\\.wu.*lasx_xvdiv_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvdiv_du:.*xvdiv\\.du.*lasx_xvdiv_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_h_b:.*xvhaddw\\.h\\.b.*lasx_xvhaddw_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_w_h:.*xvhaddw\\.w\\.h.*lasx_xvhaddw_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_d_w:.*xvhaddw\\.d\\.w.*lasx_xvhaddw_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_hu_bu:.*xvhaddw\\.hu\\.bu.*lasx_xvhaddw_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_wu_hu:.*xvhaddw\\.wu\\.hu.*lasx_xvhaddw_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_du_wu:.*xvhaddw\\.du\\.wu.*lasx_xvhaddw_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_h_b:.*xvhsubw\\.h\\.b.*lasx_xvhsubw_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_w_h:.*xvhsubw\\.w\\.h.*lasx_xvhsubw_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_d_w:.*xvhsubw\\.d\\.w.*lasx_xvhsubw_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_hu_bu:.*xvhsubw\\.hu\\.bu.*lasx_xvhsubw_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_wu_hu:.*xvhsubw\\.wu\\.hu.*lasx_xvhsubw_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_du_wu:.*xvhsubw\\.du\\.wu.*lasx_xvhsubw_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_b:.*xvmod\\.b.*lasx_xvmod_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_h:.*xvmod\\.h.*lasx_xvmod_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_w:.*xvmod\\.w.*lasx_xvmod_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_d:.*xvmod\\.d.*lasx_xvmod_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_bu:.*xvmod\\.bu.*lasx_xvmod_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_hu:.*xvmod\\.hu.*lasx_xvmod_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_wu:.*xvmod\\.wu.*lasx_xvmod_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmod_du:.*xvmod\\.du.*lasx_xvmod_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepl128vei_b:.*xvrepl128vei\\.b.*lasx_xvrepl128vei_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepl128vei_h:.*xvrepl128vei\\.h.*lasx_xvrepl128vei_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepl128vei_w:.*xvrepl128vei\\.w.*lasx_xvrepl128vei_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepl128vei_d:.*xvrepl128vei\\.d.*lasx_xvrepl128vei_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickev_b:.*xvpickev\\.b.*lasx_xvpickev_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickev_h:.*xvpickev\\.h.*lasx_xvpickev_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickev_w:.*xvpickev\\.w.*lasx_xvpickev_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickev_d:.*xvilvl\\.d.*lasx_xvpickev_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickod_b:.*xvpickod\\.b.*lasx_xvpickod_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickod_h:.*xvpickod\\.h.*lasx_xvpickod_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickod_w:.*xvpickod\\.w.*lasx_xvpickod_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickod_d:.*xvilvh\\.d.*lasx_xvpickod_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvh_b:.*xvilvh\\.b.*lasx_xvilvh_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvh_h:.*xvilvh\\.h.*lasx_xvilvh_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvh_w:.*xvilvh\\.w.*lasx_xvilvh_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvh_d:.*xvilvh\\.d.*lasx_xvilvh_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvl_b:.*xvilvl\\.b.*lasx_xvilvl_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvl_h:.*xvilvl\\.h.*lasx_xvilvl_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvl_w:.*xvilvl\\.w.*lasx_xvilvl_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvilvl_d:.*xvilvl\\.d.*lasx_xvilvl_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackev_b:.*xvpackev\\.b.*lasx_xvpackev_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackev_h:.*xvpackev\\.h.*lasx_xvpackev_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackev_w:.*xvpackev\\.w.*lasx_xvpackev_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackev_d:.*xvilvl\\.d.*lasx_xvpackev_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackod_b:.*xvpackod\\.b.*lasx_xvpackod_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackod_h:.*xvpackod\\.h.*lasx_xvpackod_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackod_w:.*xvpackod\\.w.*lasx_xvpackod_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpackod_d:.*xvilvh\\.d.*lasx_xvpackod_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf_b:.*xvshuf\\.b.*lasx_xvshuf_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf_h:.*xvshuf\\.h.*lasx_xvshuf_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf_w:.*xvshuf\\.w.*lasx_xvshuf_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf_d:.*xvshuf\\.d.*lasx_xvshuf_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvand_v:.*xvand\\.v.*lasx_xvand_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvandi_b:.*xvandi\\.b.*lasx_xvandi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvor_v:.*xvor\\.v.*lasx_xvor_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvori_b:.*xvbitseti\\.b.*lasx_xvori_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvnor_v:.*xvnor\\.v.*lasx_xvnor_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvnori_b:.*xvnori\\.b.*lasx_xvnori_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvxor_v:.*xvxor\\.v.*lasx_xvxor_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvxori_b:.*xvbitrevi\\.b.*lasx_xvxori_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitsel_v:.*xvbitsel\\.v.*lasx_xvbitsel_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbitseli_b:.*xvbitseli\\.b.*lasx_xvbitseli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf4i_b:.*xvshuf4i\\.b.*lasx_xvshuf4i_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf4i_h:.*xvshuf4i\\.h.*lasx_xvshuf4i_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf4i_w:.*xvshuf4i\\.w.*lasx_xvshuf4i_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplgr2vr_b:.*xvreplgr2vr\\.b.*lasx_xvreplgr2vr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplgr2vr_h:.*xvreplgr2vr\\.h.*lasx_xvreplgr2vr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplgr2vr_w:.*xvreplgr2vr\\.w.*lasx_xvreplgr2vr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplgr2vr_d:.*xvreplgr2vr\\.d.*lasx_xvreplgr2vr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpcnt_b:.*xvpcnt\\.b.*lasx_xvpcnt_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpcnt_h:.*xvpcnt\\.h.*lasx_xvpcnt_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpcnt_w:.*xvpcnt\\.w.*lasx_xvpcnt_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpcnt_d:.*xvpcnt\\.d.*lasx_xvpcnt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclo_b:.*xvclo\\.b.*lasx_xvclo_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclo_h:.*xvclo\\.h.*lasx_xvclo_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclo_w:.*xvclo\\.w.*lasx_xvclo_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclo_d:.*xvclo\\.d.*lasx_xvclo_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclz_b:.*xvclz\\.b.*lasx_xvclz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclz_h:.*xvclz\\.h.*lasx_xvclz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclz_w:.*xvclz\\.w.*lasx_xvclz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvclz_d:.*xvclz\\.d.*lasx_xvclz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfadd_s:.*xvfadd\\.s.*lasx_xvfadd_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfadd_d:.*xvfadd\\.d.*lasx_xvfadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfsub_s:.*xvfsub\\.s.*lasx_xvfsub_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfsub_d:.*xvfsub\\.d.*lasx_xvfsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmul_s:.*xvfmul\\.s.*lasx_xvfmul_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmul_d:.*xvfmul\\.d.*lasx_xvfmul_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfdiv_s:.*xvfdiv\\.s.*lasx_xvfdiv_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfdiv_d:.*xvfdiv\\.d.*lasx_xvfdiv_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcvt_h_s:.*xvfcvt\\.h\\.s.*lasx_xvfcvt_h_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcvt_s_d:.*xvfcvt\\.s\\.d.*lasx_xvfcvt_s_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmin_s:.*xvfmin\\.s.*lasx_xvfmin_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmin_d:.*xvfmin\\.d.*lasx_xvfmin_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmina_s:.*xvfmina\\.s.*lasx_xvfmina_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmina_d:.*xvfmina\\.d.*lasx_xvfmina_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmax_s:.*xvfmax\\.s.*lasx_xvfmax_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmax_d:.*xvfmax\\.d.*lasx_xvfmax_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmaxa_s:.*xvfmaxa\\.s.*lasx_xvfmaxa_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmaxa_d:.*xvfmaxa\\.d.*lasx_xvfmaxa_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfclass_s:.*xvfclass\\.s.*lasx_xvfclass_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfclass_d:.*xvfclass\\.d.*lasx_xvfclass_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfsqrt_s:.*xvfsqrt\\.s.*lasx_xvfsqrt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfsqrt_d:.*xvfsqrt\\.d.*lasx_xvfsqrt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrecip_s:.*xvfrecip\\.s.*lasx_xvfrecip_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrecip_d:.*xvfrecip\\.d.*lasx_xvfrecip_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrint_s:.*xvfrint\\.s.*lasx_xvfrint_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrint_d:.*xvfrint\\.d.*lasx_xvfrint_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrsqrt_s:.*xvfrsqrt\\.s.*lasx_xvfrsqrt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrsqrt_d:.*xvfrsqrt\\.d.*lasx_xvfrsqrt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvflogb_s:.*xvflogb\\.s.*lasx_xvflogb_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvflogb_d:.*xvflogb\\.d.*lasx_xvflogb_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcvth_s_h:.*xvfcvth\\.s\\.h.*lasx_xvfcvth_s_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcvth_d_s:.*xvfcvth\\.d\\.s.*lasx_xvfcvth_d_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcvtl_s_h:.*xvfcvtl\\.s\\.h.*lasx_xvfcvtl_s_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcvtl_d_s:.*xvfcvtl\\.d\\.s.*lasx_xvfcvtl_d_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftint_w_s:.*xvftint\\.w\\.s.*lasx_xvftint_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftint_l_d:.*xvftint\\.l\\.d.*lasx_xvftint_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftint_wu_s:.*xvftint\\.wu\\.s.*lasx_xvftint_wu_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftint_lu_d:.*xvftint\\.lu\\.d.*lasx_xvftint_lu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrz_w_s:.*xvftintrz\\.w\\.s.*lasx_xvftintrz_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrz_l_d:.*xvftintrz\\.l\\.d.*lasx_xvftintrz_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrz_wu_s:.*xvftintrz\\.wu\\.s.*lasx_xvftintrz_wu_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrz_lu_d:.*xvftintrz\\.lu\\.d.*lasx_xvftintrz_lu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvffint_s_w:.*xvffint\\.s\\.w.*lasx_xvffint_s_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvffint_d_l:.*xvffint\\.d\\.l.*lasx_xvffint_d_l" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvffint_s_wu:.*xvffint\\.s\\.wu.*lasx_xvffint_s_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvffint_d_lu:.*xvffint\\.d\\.lu.*lasx_xvffint_d_lu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve_b:.*xvreplve\\.b.*lasx_xvreplve_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve_h:.*xvreplve\\.h.*lasx_xvreplve_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve_w:.*xvreplve\\.w.*lasx_xvreplve_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve_d:.*xvreplve\\.d.*lasx_xvreplve_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpermi_w:.*xvpermi\\.w.*lasx_xvpermi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvandn_v:.*xvandn\\.v.*lasx_xvandn_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvneg_b:.*xvneg\\.b.*lasx_xvneg_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvneg_h:.*xvneg\\.h.*lasx_xvneg_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvneg_w:.*xvneg\\.w.*lasx_xvneg_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvneg_d:.*xvneg\\.d.*lasx_xvneg_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_b:.*xvmuh\\.b.*lasx_xvmuh_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_h:.*xvmuh\\.h.*lasx_xvmuh_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_w:.*xvmuh\\.w.*lasx_xvmuh_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_d:.*xvmuh\\.d.*lasx_xvmuh_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_bu:.*xvmuh\\.bu.*lasx_xvmuh_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_hu:.*xvmuh\\.hu.*lasx_xvmuh_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_wu:.*xvmuh\\.wu.*lasx_xvmuh_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmuh_du:.*xvmuh\\.du.*lasx_xvmuh_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsllwil_h_b:.*xvsllwil\\.h\\.b.*lasx_xvsllwil_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsllwil_w_h:.*xvsllwil\\.w\\.h.*lasx_xvsllwil_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsllwil_d_w:.*xvsllwil\\.d\\.w.*lasx_xvsllwil_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsllwil_hu_bu:.*xvsllwil\\.hu\\.bu.*lasx_xvsllwil_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsllwil_wu_hu:.*xvsllwil\\.wu\\.hu.*lasx_xvsllwil_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsllwil_du_wu:.*xvsllwil\\.du\\.wu.*lasx_xvsllwil_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsran_b_h:.*xvsran\\.b\\.h.*lasx_xvsran_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsran_h_w:.*xvsran\\.h\\.w.*lasx_xvsran_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsran_w_d:.*xvsran\\.w\\.d.*lasx_xvsran_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssran_b_h:.*xvssran\\.b\\.h.*lasx_xvssran_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssran_h_w:.*xvssran\\.h\\.w.*lasx_xvssran_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssran_w_d:.*xvssran\\.w\\.d.*lasx_xvssran_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssran_bu_h:.*xvssran\\.bu\\.h.*lasx_xvssran_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssran_hu_w:.*xvssran\\.hu\\.w.*lasx_xvssran_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssran_wu_d:.*xvssran\\.wu\\.d.*lasx_xvssran_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrarn_b_h:.*xvsrarn\\.b\\.h.*lasx_xvsrarn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrarn_h_w:.*xvsrarn\\.h\\.w.*lasx_xvsrarn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrarn_w_d:.*xvsrarn\\.w\\.d.*lasx_xvsrarn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarn_b_h:.*xvssrarn\\.b\\.h.*lasx_xvssrarn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarn_h_w:.*xvssrarn\\.h\\.w.*lasx_xvssrarn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarn_w_d:.*xvssrarn\\.w\\.d.*lasx_xvssrarn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarn_bu_h:.*xvssrarn\\.bu\\.h.*lasx_xvssrarn_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarn_hu_w:.*xvssrarn\\.hu\\.w.*lasx_xvssrarn_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarn_wu_d:.*xvssrarn\\.wu\\.d.*lasx_xvssrarn_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrln_b_h:.*xvsrln\\.b\\.h.*lasx_xvsrln_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrln_h_w:.*xvsrln\\.h\\.w.*lasx_xvsrln_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrln_w_d:.*xvsrln\\.w\\.d.*lasx_xvsrln_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrln_bu_h:.*xvssrln\\.bu\\.h.*lasx_xvssrln_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrln_hu_w:.*xvssrln\\.hu\\.w.*lasx_xvssrln_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrln_wu_d:.*xvssrln\\.wu\\.d.*lasx_xvssrln_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlrn_b_h:.*xvsrlrn\\.b\\.h.*lasx_xvsrlrn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlrn_h_w:.*xvsrlrn\\.h\\.w.*lasx_xvsrlrn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlrn_w_d:.*xvsrlrn\\.w\\.d.*lasx_xvsrlrn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrn_bu_h:.*xvssrlrn\\.bu\\.h.*lasx_xvssrlrn_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrn_hu_w:.*xvssrlrn\\.hu\\.w.*lasx_xvssrlrn_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrn_wu_d:.*xvssrlrn\\.wu\\.d.*lasx_xvssrlrn_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrstpi_b:.*xvfrstpi\\.b.*lasx_xvfrstpi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrstpi_h:.*xvfrstpi\\.h.*lasx_xvfrstpi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrstp_b:.*xvfrstp\\.b.*lasx_xvfrstp_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrstp_h:.*xvfrstp\\.h.*lasx_xvfrstp_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvshuf4i_d:.*xvshuf4i\\.d.*lasx_xvshuf4i_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbsrl_v:.*xvbsrl\\.v.*lasx_xvbsrl_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvbsll_v:.*xvbsll\\.v.*lasx_xvbsll_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvextrins_b:.*xvextrins\\.b.*lasx_xvextrins_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvextrins_h:.*xvextrins\\.h.*lasx_xvextrins_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvextrins_w:.*xvextrins\\.w.*lasx_xvextrins_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvextrins_d:.*xvextrins\\.d.*lasx_xvextrins_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmskltz_b:.*xvmskltz\\.b.*lasx_xvmskltz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmskltz_h:.*xvmskltz\\.h.*lasx_xvmskltz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmskltz_w:.*xvmskltz\\.w.*lasx_xvmskltz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmskltz_d:.*xvmskltz\\.d.*lasx_xvmskltz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsigncov_b:.*xvsigncov\\.b.*lasx_xvsigncov_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsigncov_h:.*xvsigncov\\.h.*lasx_xvsigncov_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsigncov_w:.*xvsigncov\\.w.*lasx_xvsigncov_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsigncov_d:.*xvsigncov\\.d.*lasx_xvsigncov_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmadd_s:.*xvfmadd\\.s.*lasx_xvfmadd_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmadd_d:.*xvfmadd\\.d.*lasx_xvfmadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmsub_s:.*xvfmsub\\.s.*lasx_xvfmsub_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfmsub_d:.*xvfmsub\\.d.*lasx_xvfmsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfnmadd_s:.*xvfnmadd\\.s.*lasx_xvfnmadd_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfnmadd_d:.*xvfnmadd\\.d.*lasx_xvfnmadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfnmsub_s:.*xvfnmsub\\.s.*lasx_xvfnmsub_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfnmsub_d:.*xvfnmsub\\.d.*lasx_xvfnmsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrne_w_s:.*xvftintrne\\.w\\.s.*lasx_xvftintrne_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrne_l_d:.*xvftintrne\\.l\\.d.*lasx_xvftintrne_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrp_w_s:.*xvftintrp\\.w\\.s.*lasx_xvftintrp_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrp_l_d:.*xvftintrp\\.l\\.d.*lasx_xvftintrp_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrm_w_s:.*xvftintrm\\.w\\.s.*lasx_xvftintrm_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrm_l_d:.*xvftintrm\\.l\\.d.*lasx_xvftintrm_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftint_w_d:.*xvftint\\.w\\.d.*lasx_xvftint_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvffint_s_l:.*xvffint\\.s\\.l.*lasx_xvffint_s_l" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrz_w_d:.*xvftintrz\\.w\\.d.*lasx_xvftintrz_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrp_w_d:.*xvftintrp\\.w\\.d.*lasx_xvftintrp_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrm_w_d:.*xvftintrm\\.w\\.d.*lasx_xvftintrm_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrne_w_d:.*xvftintrne\\.w\\.d.*lasx_xvftintrne_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftinth_l_s:.*xvftinth\\.l\\.s.*lasx_xvftinth_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintl_l_s:.*xvftintl\\.l\\.s.*lasx_xvftintl_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvffinth_d_w:.*xvffinth\\.d\\.w.*lasx_xvffinth_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvffintl_d_w:.*xvffintl\\.d\\.w.*lasx_xvffintl_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrzh_l_s:.*xvftintrzh\\.l\\.s.*lasx_xvftintrzh_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrzl_l_s:.*xvftintrzl\\.l\\.s.*lasx_xvftintrzl_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrph_l_s:.*xvftintrph\\.l\\.s.*lasx_xvftintrph_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrpl_l_s:.*xvftintrpl\\.l\\.s.*lasx_xvftintrpl_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrmh_l_s:.*xvftintrmh\\.l\\.s.*lasx_xvftintrmh_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrml_l_s:.*xvftintrml\\.l\\.s.*lasx_xvftintrml_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrneh_l_s:.*xvftintrneh\\.l\\.s.*lasx_xvftintrneh_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvftintrnel_l_s:.*xvftintrnel\\.l\\.s.*lasx_xvftintrnel_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrne_s:.*xvfrintrne\\.s.*lasx_xvfrintrne_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrne_d:.*xvfrintrne\\.d.*lasx_xvfrintrne_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrz_s:.*xvfrintrz\\.s.*lasx_xvfrintrz_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrz_d:.*xvfrintrz\\.d.*lasx_xvfrintrz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrp_s:.*xvfrintrp\\.s.*lasx_xvfrintrp_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrp_d:.*xvfrintrp\\.d.*lasx_xvfrintrp_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrm_s:.*xvfrintrm\\.s.*lasx_xvfrintrm_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfrintrm_d:.*xvfrintrm\\.d.*lasx_xvfrintrm_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvld:.*xvld.*lasx_xvld" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvst:.*xvst.*lasx_xvst" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvstelm_b:.*xvstelm\\.b.*lasx_xvstelm_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvstelm_h:.*xvstelm\\.h.*lasx_xvstelm_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvstelm_w:.*xvstelm\\.w.*lasx_xvstelm_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvstelm_d:.*xvstelm\\.d.*lasx_xvstelm_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvinsve0_w:.*xvinsve0\\.w.*lasx_xvinsve0_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvinsve0_d:.*xvinsve0\\.d.*lasx_xvinsve0_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve_w:.*xvpickve\\.w.*lasx_xvpickve_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve_d:.*xvpickve\\.d.*lasx_xvpickve_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrn_b_h:.*xvssrlrn\\.b\\.h.*lasx_xvssrlrn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrn_h_w:.*xvssrlrn\\.h\\.w.*lasx_xvssrlrn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrn_w_d:.*xvssrlrn\\.w\\.d.*lasx_xvssrlrn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrln_b_h:.*xvssrln\\.b\\.h.*lasx_xvssrln_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrln_h_w:.*xvssrln\\.h\\.w.*lasx_xvssrln_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrln_w_d:.*xvssrln\\.w\\.d.*lasx_xvssrln_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvorn_v:.*xvorn\\.v.*lasx_xvorn_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvldi:.*xvldi.*lasx_xvldi" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvldx:.*xvldx.*lasx_xvldx" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvstx:.*xvstx.*lasx_xvstx" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvextl_qu_du:.*xvextl\\.qu\\.du.*lasx_xvextl_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvinsgr2vr_w:.*xvinsgr2vr\\.w.*lasx_xvinsgr2vr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvinsgr2vr_d:.*xvinsgr2vr\\.d.*lasx_xvinsgr2vr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve0_b:.*xvreplve0\\.b.*lasx_xvreplve0_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve0_h:.*xvreplve0\\.h.*lasx_xvreplve0_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve0_w:.*xvreplve0\\.w.*lasx_xvreplve0_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve0_d:.*xvreplve0\\.d.*lasx_xvreplve0_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvreplve0_q:.*xvreplve0\\.q.*lasx_xvreplve0_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_h_b:.*vext2xv\\.h\\.b.*lasx_vext2xv_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_w_h:.*vext2xv\\.w\\.h.*lasx_vext2xv_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_d_w:.*vext2xv\\.d\\.w.*lasx_vext2xv_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_w_b:.*vext2xv\\.w\\.b.*lasx_vext2xv_w_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_d_h:.*vext2xv\\.d\\.h.*lasx_vext2xv_d_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_d_b:.*vext2xv\\.d\\.b.*lasx_vext2xv_d_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_hu_bu:.*vext2xv\\.hu\\.bu.*lasx_vext2xv_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_wu_hu:.*vext2xv\\.wu\\.hu.*lasx_vext2xv_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_du_wu:.*vext2xv\\.du\\.wu.*lasx_vext2xv_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_wu_bu:.*vext2xv\\.wu\\.bu.*lasx_vext2xv_wu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_du_hu:.*vext2xv\\.du\\.hu.*lasx_vext2xv_du_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_vext2xv_du_bu:.*vext2xv\\.du\\.bu.*lasx_vext2xv_du_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpermi_q:.*xvpermi\\.q.*lasx_xvpermi_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpermi_d:.*xvpermi\\.d.*lasx_xvpermi_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvperm_w:.*xvperm\\.w.*lasx_xvperm_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvldrepl_b:.*xvldrepl\\.b.*lasx_xvldrepl_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvldrepl_h:.*xvldrepl\\.h.*lasx_xvldrepl_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvldrepl_w:.*xvldrepl\\.w.*lasx_xvldrepl_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvldrepl_d:.*xvldrepl\\.d.*lasx_xvldrepl_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve2gr_w:.*xvpickve2gr\\.w.*lasx_xvpickve2gr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve2gr_wu:.*xvpickve2gr\\.wu.*lasx_xvpickve2gr_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve2gr_d:.*xvpickve2gr\\.d.*lasx_xvpickve2gr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve2gr_du:.*xvpickve2gr\\.du.*lasx_xvpickve2gr_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_q_d:.*xvaddwev\\.q\\.d.*lasx_xvaddwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_d_w:.*xvaddwev\\.d\\.w.*lasx_xvaddwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_w_h:.*xvaddwev\\.w\\.h.*lasx_xvaddwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_h_b:.*xvaddwev\\.h\\.b.*lasx_xvaddwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_q_du:.*xvaddwev\\.q\\.du.*lasx_xvaddwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_d_wu:.*xvaddwev\\.d\\.wu.*lasx_xvaddwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_w_hu:.*xvaddwev\\.w\\.hu.*lasx_xvaddwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_h_bu:.*xvaddwev\\.h\\.bu.*lasx_xvaddwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_q_d:.*xvsubwev\\.q\\.d.*lasx_xvsubwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_d_w:.*xvsubwev\\.d\\.w.*lasx_xvsubwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_w_h:.*xvsubwev\\.w\\.h.*lasx_xvsubwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_h_b:.*xvsubwev\\.h\\.b.*lasx_xvsubwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_q_du:.*xvsubwev\\.q\\.du.*lasx_xvsubwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_d_wu:.*xvsubwev\\.d\\.wu.*lasx_xvsubwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_w_hu:.*xvsubwev\\.w\\.hu.*lasx_xvsubwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwev_h_bu:.*xvsubwev\\.h\\.bu.*lasx_xvsubwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_q_d:.*xvmulwev\\.q\\.d.*lasx_xvmulwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_d_w:.*xvmulwev\\.d\\.w.*lasx_xvmulwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_w_h:.*xvmulwev\\.w\\.h.*lasx_xvmulwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_h_b:.*xvmulwev\\.h\\.b.*lasx_xvmulwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_q_du:.*xvmulwev\\.q\\.du.*lasx_xvmulwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_d_wu:.*xvmulwev\\.d\\.wu.*lasx_xvmulwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_w_hu:.*xvmulwev\\.w\\.hu.*lasx_xvmulwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_h_bu:.*xvmulwev\\.h\\.bu.*lasx_xvmulwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_q_d:.*xvaddwod\\.q\\.d.*lasx_xvaddwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_d_w:.*xvaddwod\\.d\\.w.*lasx_xvaddwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_w_h:.*xvaddwod\\.w\\.h.*lasx_xvaddwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_h_b:.*xvaddwod\\.h\\.b.*lasx_xvaddwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_q_du:.*xvaddwod\\.q\\.du.*lasx_xvaddwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_d_wu:.*xvaddwod\\.d\\.wu.*lasx_xvaddwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_w_hu:.*xvaddwod\\.w\\.hu.*lasx_xvaddwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_h_bu:.*xvaddwod\\.h\\.bu.*lasx_xvaddwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_q_d:.*xvsubwod\\.q\\.d.*lasx_xvsubwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_d_w:.*xvsubwod\\.d\\.w.*lasx_xvsubwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_w_h:.*xvsubwod\\.w\\.h.*lasx_xvsubwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_h_b:.*xvsubwod\\.h\\.b.*lasx_xvsubwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_q_du:.*xvsubwod\\.q\\.du.*lasx_xvsubwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_d_wu:.*xvsubwod\\.d\\.wu.*lasx_xvsubwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_w_hu:.*xvsubwod\\.w\\.hu.*lasx_xvsubwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsubwod_h_bu:.*xvsubwod\\.h\\.bu.*lasx_xvsubwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_q_d:.*xvmulwod\\.q\\.d.*lasx_xvmulwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_d_w:.*xvmulwod\\.d\\.w.*lasx_xvmulwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_w_h:.*xvmulwod\\.w\\.h.*lasx_xvmulwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_h_b:.*xvmulwod\\.h\\.b.*lasx_xvmulwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_q_du:.*xvmulwod\\.q\\.du.*lasx_xvmulwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_d_wu:.*xvmulwod\\.d\\.wu.*lasx_xvmulwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_w_hu:.*xvmulwod\\.w\\.hu.*lasx_xvmulwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_h_bu:.*xvmulwod\\.h\\.bu.*lasx_xvmulwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_d_wu_w:.*xvaddwev\\.d\\.wu\\.w.*lasx_xvaddwev_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_w_hu_h:.*xvaddwev\\.w\\.hu\\.h.*lasx_xvaddwev_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_h_bu_b:.*xvaddwev\\.h\\.bu\\.b.*lasx_xvaddwev_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_d_wu_w:.*xvmulwev\\.d\\.wu\\.w.*lasx_xvmulwev_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_w_hu_h:.*xvmulwev\\.w\\.hu\\.h.*lasx_xvmulwev_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_h_bu_b:.*xvmulwev\\.h\\.bu\\.b.*lasx_xvmulwev_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_d_wu_w:.*xvaddwod\\.d\\.wu\\.w.*lasx_xvaddwod_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_w_hu_h:.*xvaddwod\\.w\\.hu\\.h.*lasx_xvaddwod_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_h_bu_b:.*xvaddwod\\.h\\.bu\\.b.*lasx_xvaddwod_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_d_wu_w:.*xvmulwod\\.d\\.wu\\.w.*lasx_xvmulwod_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_w_hu_h:.*xvmulwod\\.w\\.hu\\.h.*lasx_xvmulwod_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_h_bu_b:.*xvmulwod\\.h\\.bu\\.b.*lasx_xvmulwod_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_q_d:.*xvhaddw\\.q\\.d.*lasx_xvhaddw_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhaddw_qu_du:.*xvhaddw\\.qu\\.du.*lasx_xvhaddw_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_q_d:.*xvhsubw\\.q\\.d.*lasx_xvhsubw_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvhsubw_qu_du:.*xvhsubw\\.qu\\.du.*lasx_xvhsubw_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_q_d:.*xvmaddwev\\.q\\.d.*lasx_xvmaddwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_d_w:.*xvmaddwev\\.d\\.w.*lasx_xvmaddwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_w_h:.*xvmaddwev\\.w\\.h.*lasx_xvmaddwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_h_b:.*xvmaddwev\\.h\\.b.*lasx_xvmaddwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_q_du:.*xvmaddwev\\.q\\.du.*lasx_xvmaddwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_d_wu:.*xvmaddwev\\.d\\.wu.*lasx_xvmaddwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_w_hu:.*xvmaddwev\\.w\\.hu.*lasx_xvmaddwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_h_bu:.*xvmaddwev\\.h\\.bu.*lasx_xvmaddwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_q_d:.*xvmaddwod\\.q\\.d.*lasx_xvmaddwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_d_w:.*xvmaddwod\\.d\\.w.*lasx_xvmaddwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_w_h:.*xvmaddwod\\.w\\.h.*lasx_xvmaddwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_h_b:.*xvmaddwod\\.h\\.b.*lasx_xvmaddwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_q_du:.*xvmaddwod\\.q\\.du.*lasx_xvmaddwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_d_wu:.*xvmaddwod\\.d\\.wu.*lasx_xvmaddwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_w_hu:.*xvmaddwod\\.w\\.hu.*lasx_xvmaddwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_h_bu:.*xvmaddwod\\.h\\.bu.*lasx_xvmaddwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_q_du_d:.*xvmaddwev\\.q\\.du\\.d.*lasx_xvmaddwev_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_d_wu_w:.*xvmaddwev\\.d\\.wu\\.w.*lasx_xvmaddwev_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_w_hu_h:.*xvmaddwev\\.w\\.hu\\.h.*lasx_xvmaddwev_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwev_h_bu_b:.*xvmaddwev\\.h\\.bu\\.b.*lasx_xvmaddwev_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_q_du_d:.*xvmaddwod\\.q\\.du\\.d.*lasx_xvmaddwod_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_d_wu_w:.*xvmaddwod\\.d\\.wu\\.w.*lasx_xvmaddwod_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_w_hu_h:.*xvmaddwod\\.w\\.hu\\.h.*lasx_xvmaddwod_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmaddwod_h_bu_b:.*xvmaddwod\\.h\\.bu\\.b.*lasx_xvmaddwod_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotr_b:.*xvrotr\\.b.*lasx_xvrotr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotr_h:.*xvrotr\\.h.*lasx_xvrotr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotr_w:.*xvrotr\\.w.*lasx_xvrotr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotr_d:.*xvrotr\\.d.*lasx_xvrotr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvadd_q:.*xvadd\\.q.*lasx_xvadd_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsub_q:.*xvsub\\.q.*lasx_xvsub_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwev_q_du_d:.*xvaddwev\\.q\\.du\\.d.*lasx_xvaddwev_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvaddwod_q_du_d:.*xvaddwod\\.q\\.du\\.d.*lasx_xvaddwod_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwev_q_du_d:.*xvmulwev\\.q\\.du\\.d.*lasx_xvmulwev_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmulwod_q_du_d:.*xvmulwod\\.q\\.du\\.d.*lasx_xvmulwod_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmskgez_b:.*xvmskgez\\.b.*lasx_xvmskgez_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvmsknz_b:.*xvmsknz\\.b.*lasx_xvmsknz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_h_b:.*xvexth\\.h\\.b.*lasx_xvexth_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_w_h:.*xvexth\\.w\\.h.*lasx_xvexth_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_d_w:.*xvexth\\.d\\.w.*lasx_xvexth_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_q_d:.*xvexth\\.q\\.d.*lasx_xvexth_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_hu_bu:.*xvexth\\.hu\\.bu.*lasx_xvexth_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_wu_hu:.*xvexth\\.wu\\.hu.*lasx_xvexth_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_du_wu:.*xvexth\\.du\\.wu.*lasx_xvexth_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvexth_qu_du:.*xvexth\\.qu\\.du.*lasx_xvexth_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotri_b:.*xvrotri\\.b.*lasx_xvrotri_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotri_h:.*xvrotri\\.h.*lasx_xvrotri_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotri_w:.*xvrotri\\.w.*lasx_xvrotri_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrotri_d:.*xvrotri\\.d.*lasx_xvrotri_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvextl_q_d:.*xvextl\\.q\\.d.*lasx_xvextl_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlni_b_h:.*xvsrlni\\.b\\.h.*lasx_xvsrlni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlni_h_w:.*xvsrlni\\.h\\.w.*lasx_xvsrlni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlni_w_d:.*xvsrlni\\.w\\.d.*lasx_xvsrlni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlni_d_q:.*xvsrlni\\.d\\.q.*lasx_xvsrlni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlrni_b_h:.*xvsrlrni\\.b\\.h.*lasx_xvsrlrni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlrni_h_w:.*xvsrlrni\\.h\\.w.*lasx_xvsrlrni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlrni_w_d:.*xvsrlrni\\.w\\.d.*lasx_xvsrlrni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrlrni_d_q:.*xvsrlrni\\.d\\.q.*lasx_xvsrlrni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_b_h:.*xvssrlni\\.b\\.h.*lasx_xvssrlni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_h_w:.*xvssrlni\\.h\\.w.*lasx_xvssrlni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_w_d:.*xvssrlni\\.w\\.d.*lasx_xvssrlni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_d_q:.*xvssrlni\\.d\\.q.*lasx_xvssrlni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_bu_h:.*xvssrlni\\.bu\\.h.*lasx_xvssrlni_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_hu_w:.*xvssrlni\\.hu\\.w.*lasx_xvssrlni_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_wu_d:.*xvssrlni\\.wu\\.d.*lasx_xvssrlni_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlni_du_q:.*xvssrlni\\.du\\.q.*lasx_xvssrlni_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_b_h:.*xvssrlrni\\.b\\.h.*lasx_xvssrlrni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_h_w:.*xvssrlrni\\.h\\.w.*lasx_xvssrlrni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_w_d:.*xvssrlrni\\.w\\.d.*lasx_xvssrlrni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_d_q:.*xvssrlrni\\.d\\.q.*lasx_xvssrlrni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_bu_h:.*xvssrlrni\\.bu\\.h.*lasx_xvssrlrni_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_hu_w:.*xvssrlrni\\.hu\\.w.*lasx_xvssrlrni_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_wu_d:.*xvssrlrni\\.wu\\.d.*lasx_xvssrlrni_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrlrni_du_q:.*xvssrlrni\\.du\\.q.*lasx_xvssrlrni_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrani_b_h:.*xvsrani\\.b\\.h.*lasx_xvsrani_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrani_h_w:.*xvsrani\\.h\\.w.*lasx_xvsrani_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrani_w_d:.*xvsrani\\.w\\.d.*lasx_xvsrani_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrani_d_q:.*xvsrani\\.d\\.q.*lasx_xvsrani_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrarni_b_h:.*xvsrarni\\.b\\.h.*lasx_xvsrarni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrarni_h_w:.*xvsrarni\\.h\\.w.*lasx_xvsrarni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrarni_w_d:.*xvsrarni\\.w\\.d.*lasx_xvsrarni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvsrarni_d_q:.*xvsrarni\\.d\\.q.*lasx_xvsrarni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_b_h:.*xvssrani\\.b\\.h.*lasx_xvssrani_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_h_w:.*xvssrani\\.h\\.w.*lasx_xvssrani_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_w_d:.*xvssrani\\.w\\.d.*lasx_xvssrani_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_d_q:.*xvssrani\\.d\\.q.*lasx_xvssrani_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_bu_h:.*xvssrani\\.bu\\.h.*lasx_xvssrani_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_hu_w:.*xvssrani\\.hu\\.w.*lasx_xvssrani_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_wu_d:.*xvssrani\\.wu\\.d.*lasx_xvssrani_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrani_du_q:.*xvssrani\\.du\\.q.*lasx_xvssrani_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_b_h:.*xvssrarni\\.b\\.h.*lasx_xvssrarni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_h_w:.*xvssrarni\\.h\\.w.*lasx_xvssrarni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_w_d:.*xvssrarni\\.w\\.d.*lasx_xvssrarni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_d_q:.*xvssrarni\\.d\\.q.*lasx_xvssrarni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_bu_h:.*xvssrarni\\.bu\\.h.*lasx_xvssrarni_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_hu_w:.*xvssrarni\\.hu\\.w.*lasx_xvssrarni_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_wu_d:.*xvssrarni\\.wu\\.d.*lasx_xvssrarni_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvssrarni_du_q:.*xvssrarni\\.du\\.q.*lasx_xvssrarni_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbnz_b:.*xvsetanyeqz\\.b.*lasx_xbnz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbnz_d:.*xvsetanyeqz\\.d.*lasx_xbnz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbnz_h:.*xvsetanyeqz\\.h.*lasx_xbnz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbnz_v:.*xvseteqz\\.v.*lasx_xbnz_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbnz_w:.*xvsetanyeqz\\.w.*lasx_xbnz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbz_b:.*xvsetallnez\\.b.*lasx_xbz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbz_d:.*xvsetallnez\\.d.*lasx_xbz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbz_h:.*xvsetallnez\\.h.*lasx_xbz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbz_v:.*xvsetnez\\.v.*lasx_xbz_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xbz_w:.*xvsetallnez\\.w.*lasx_xbz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_caf_d:.*xvfcmp\\.caf\\.d.*lasx_xvfcmp_caf_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_caf_s:.*xvfcmp\\.caf\\.s.*lasx_xvfcmp_caf_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_ceq_d:.*xvfcmp\\.ceq\\.d.*lasx_xvfcmp_ceq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_ceq_s:.*xvfcmp\\.ceq\\.s.*lasx_xvfcmp_ceq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cle_d:.*xvfcmp\\.cle\\.d.*lasx_xvfcmp_cle_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cle_s:.*xvfcmp\\.cle\\.s.*lasx_xvfcmp_cle_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_clt_d:.*xvfcmp\\.clt\\.d.*lasx_xvfcmp_clt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_clt_s:.*xvfcmp\\.clt\\.s.*lasx_xvfcmp_clt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cne_d:.*xvfcmp\\.cne\\.d.*lasx_xvfcmp_cne_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cne_s:.*xvfcmp\\.cne\\.s.*lasx_xvfcmp_cne_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cor_d:.*xvfcmp\\.cor\\.d.*lasx_xvfcmp_cor_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cor_s:.*xvfcmp\\.cor\\.s.*lasx_xvfcmp_cor_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cueq_d:.*xvfcmp\\.cueq\\.d.*lasx_xvfcmp_cueq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cueq_s:.*xvfcmp\\.cueq\\.s.*lasx_xvfcmp_cueq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cule_d:.*xvfcmp\\.cule\\.d.*lasx_xvfcmp_cule_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cule_s:.*xvfcmp\\.cule\\.s.*lasx_xvfcmp_cule_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cult_d:.*xvfcmp\\.cult\\.d.*lasx_xvfcmp_cult_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cult_s:.*xvfcmp\\.cult\\.s.*lasx_xvfcmp_cult_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cun_d:.*xvfcmp\\.cun\\.d.*lasx_xvfcmp_cun_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cune_d:.*xvfcmp\\.cune\\.d.*lasx_xvfcmp_cune_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cune_s:.*xvfcmp\\.cune\\.s.*lasx_xvfcmp_cune_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_cun_s:.*xvfcmp\\.cun\\.s.*lasx_xvfcmp_cun_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_saf_d:.*xvfcmp\\.saf\\.d.*lasx_xvfcmp_saf_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_saf_s:.*xvfcmp\\.saf\\.s.*lasx_xvfcmp_saf_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_seq_d:.*xvfcmp\\.seq\\.d.*lasx_xvfcmp_seq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_seq_s:.*xvfcmp\\.seq\\.s.*lasx_xvfcmp_seq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sle_d:.*xvfcmp\\.sle\\.d.*lasx_xvfcmp_sle_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sle_s:.*xvfcmp\\.sle\\.s.*lasx_xvfcmp_sle_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_slt_d:.*xvfcmp\\.slt\\.d.*lasx_xvfcmp_slt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_slt_s:.*xvfcmp\\.slt\\.s.*lasx_xvfcmp_slt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sne_d:.*xvfcmp\\.sne\\.d.*lasx_xvfcmp_sne_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sne_s:.*xvfcmp\\.sne\\.s.*lasx_xvfcmp_sne_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sor_d:.*xvfcmp\\.sor\\.d.*lasx_xvfcmp_sor_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sor_s:.*xvfcmp\\.sor\\.s.*lasx_xvfcmp_sor_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sueq_d:.*xvfcmp\\.sueq\\.d.*lasx_xvfcmp_sueq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sueq_s:.*xvfcmp\\.sueq\\.s.*lasx_xvfcmp_sueq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sule_d:.*xvfcmp\\.sule\\.d.*lasx_xvfcmp_sule_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sule_s:.*xvfcmp\\.sule\\.s.*lasx_xvfcmp_sule_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sult_d:.*xvfcmp\\.sult\\.d.*lasx_xvfcmp_sult_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sult_s:.*xvfcmp\\.sult\\.s.*lasx_xvfcmp_sult_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sun_d:.*xvfcmp\\.sun\\.d.*lasx_xvfcmp_sun_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sune_d:.*xvfcmp\\.sune\\.d.*lasx_xvfcmp_sune_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sune_s:.*xvfcmp\\.sune\\.s.*lasx_xvfcmp_sune_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvfcmp_sun_s:.*xvfcmp\\.sun\\.s.*lasx_xvfcmp_sun_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve_d_f:.*xvpickve\\.d.*lasx_xvpickve_d_f" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvpickve_w_f:.*xvpickve\\.w.*lasx_xvpickve_w_f" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepli_b:.*xvrepli\\.b.*lasx_xvrepli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepli_d:.*xvrepli\\.d.*lasx_xvrepli_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepli_h:.*xvrepli\\.h.*lasx_xvrepli_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lasx_xvrepli_w:.*xvrepli\\.w.*lasx_xvrepli_w" 1 } } */ ++ ++typedef signed char v32i8 __attribute__ ((vector_size (32), aligned (32))); ++typedef signed char v32i8_b __attribute__ ((vector_size (32), aligned (1))); ++typedef unsigned char v32u8 __attribute__ ((vector_size (32), aligned (32))); ++typedef unsigned char v32u8_b __attribute__ ((vector_size (32), aligned (1))); ++typedef short v16i16 __attribute__ ((vector_size (32), aligned (32))); ++typedef short v16i16_h __attribute__ ((vector_size (32), aligned (2))); ++typedef unsigned short v16u16 __attribute__ ((vector_size (32), aligned (32))); ++typedef unsigned short v16u16_h ++ __attribute__ ((vector_size (32), aligned (2))); ++typedef int v8i32 __attribute__ ((vector_size (32), aligned (32))); ++typedef int v8i32_w __attribute__ ((vector_size (32), aligned (4))); ++typedef unsigned int v8u32 __attribute__ ((vector_size (32), aligned (32))); ++typedef unsigned int v8u32_w __attribute__ ((vector_size (32), aligned (4))); ++typedef long long v4i64 __attribute__ ((vector_size (32), aligned (32))); ++typedef long long v4i64_d __attribute__ ((vector_size (32), aligned (8))); ++typedef unsigned long long v4u64 ++ __attribute__ ((vector_size (32), aligned (32))); ++typedef unsigned long long v4u64_d ++ __attribute__ ((vector_size (32), aligned (8))); ++typedef float v8f32 __attribute__ ((vector_size (32), aligned (32))); ++typedef float v8f32_w __attribute__ ((vector_size (32), aligned (4))); ++typedef double v4f64 __attribute__ ((vector_size (32), aligned (32))); ++typedef double v4f64_d __attribute__ ((vector_size (32), aligned (8))); ++ ++typedef double v4f64 __attribute__ ((vector_size (32), aligned (32))); ++typedef double v4f64_d __attribute__ ((vector_size (32), aligned (8))); ++ ++typedef float __m256 __attribute__ ((__vector_size__ (32), __may_alias__)); ++typedef long long __m256i ++ __attribute__ ((__vector_size__ (32), __may_alias__)); ++typedef double __m256d __attribute__ ((__vector_size__ (32), __may_alias__)); ++ ++/* Unaligned version of the same types. */ ++typedef float __m256_u ++ __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1))); ++typedef long long __m256i_u ++ __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1))); ++typedef double __m256d_u ++ __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1))); ++ ++v32i8 ++__lasx_xvsll_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsll_b (_1, _2); ++} ++v16i16 ++__lasx_xvsll_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsll_h (_1, _2); ++} ++v8i32 ++__lasx_xvsll_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsll_w (_1, _2); ++} ++v4i64 ++__lasx_xvsll_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsll_d (_1, _2); ++} ++v32i8 ++__lasx_xvslli_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvslli_b (_1, 1); ++} ++v16i16 ++__lasx_xvslli_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvslli_h (_1, 1); ++} ++v8i32 ++__lasx_xvslli_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvslli_w (_1, 1); ++} ++v4i64 ++__lasx_xvslli_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvslli_d (_1, 1); ++} ++v32i8 ++__lasx_xvsra_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsra_b (_1, _2); ++} ++v16i16 ++__lasx_xvsra_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsra_h (_1, _2); ++} ++v8i32 ++__lasx_xvsra_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsra_w (_1, _2); ++} ++v4i64 ++__lasx_xvsra_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsra_d (_1, _2); ++} ++v32i8 ++__lasx_xvsrai_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvsrai_b (_1, 1); ++} ++v16i16 ++__lasx_xvsrai_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvsrai_h (_1, 1); ++} ++v8i32 ++__lasx_xvsrai_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvsrai_w (_1, 1); ++} ++v4i64 ++__lasx_xvsrai_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvsrai_d (_1, 1); ++} ++v32i8 ++__lasx_xvsrar_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsrar_b (_1, _2); ++} ++v16i16 ++__lasx_xvsrar_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrar_h (_1, _2); ++} ++v8i32 ++__lasx_xvsrar_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrar_w (_1, _2); ++} ++v4i64 ++__lasx_xvsrar_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrar_d (_1, _2); ++} ++v32i8 ++__lasx_xvsrari_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvsrari_b (_1, 1); ++} ++v16i16 ++__lasx_xvsrari_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvsrari_h (_1, 1); ++} ++v8i32 ++__lasx_xvsrari_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvsrari_w (_1, 1); ++} ++v4i64 ++__lasx_xvsrari_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvsrari_d (_1, 1); ++} ++v32i8 ++__lasx_xvsrl_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsrl_b (_1, _2); ++} ++v16i16 ++__lasx_xvsrl_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrl_h (_1, _2); ++} ++v8i32 ++__lasx_xvsrl_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrl_w (_1, _2); ++} ++v4i64 ++__lasx_xvsrl_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrl_d (_1, _2); ++} ++v32i8 ++__lasx_xvsrli_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvsrli_b (_1, 1); ++} ++v16i16 ++__lasx_xvsrli_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvsrli_h (_1, 1); ++} ++v8i32 ++__lasx_xvsrli_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvsrli_w (_1, 1); ++} ++v4i64 ++__lasx_xvsrli_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvsrli_d (_1, 1); ++} ++v32i8 ++__lasx_xvsrlr_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsrlr_b (_1, _2); ++} ++v16i16 ++__lasx_xvsrlr_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrlr_h (_1, _2); ++} ++v8i32 ++__lasx_xvsrlr_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrlr_w (_1, _2); ++} ++v4i64 ++__lasx_xvsrlr_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrlr_d (_1, _2); ++} ++v32i8 ++__lasx_xvsrlri_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvsrlri_b (_1, 1); ++} ++v16i16 ++__lasx_xvsrlri_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvsrlri_h (_1, 1); ++} ++v8i32 ++__lasx_xvsrlri_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvsrlri_w (_1, 1); ++} ++v4i64 ++__lasx_xvsrlri_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvsrlri_d (_1, 1); ++} ++v32u8 ++__lasx_xvbitclr_b (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvbitclr_b (_1, _2); ++} ++v16u16 ++__lasx_xvbitclr_h (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvbitclr_h (_1, _2); ++} ++v8u32 ++__lasx_xvbitclr_w (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvbitclr_w (_1, _2); ++} ++v4u64 ++__lasx_xvbitclr_d (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvbitclr_d (_1, _2); ++} ++v32u8 ++__lasx_xvbitclri_b (v32u8 _1) ++{ ++ return __builtin_lasx_xvbitclri_b (_1, 1); ++} ++v16u16 ++__lasx_xvbitclri_h (v16u16 _1) ++{ ++ return __builtin_lasx_xvbitclri_h (_1, 1); ++} ++v8u32 ++__lasx_xvbitclri_w (v8u32 _1) ++{ ++ return __builtin_lasx_xvbitclri_w (_1, 1); ++} ++v4u64 ++__lasx_xvbitclri_d (v4u64 _1) ++{ ++ return __builtin_lasx_xvbitclri_d (_1, 1); ++} ++v32u8 ++__lasx_xvbitset_b (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvbitset_b (_1, _2); ++} ++v16u16 ++__lasx_xvbitset_h (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvbitset_h (_1, _2); ++} ++v8u32 ++__lasx_xvbitset_w (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvbitset_w (_1, _2); ++} ++v4u64 ++__lasx_xvbitset_d (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvbitset_d (_1, _2); ++} ++v32u8 ++__lasx_xvbitseti_b (v32u8 _1) ++{ ++ return __builtin_lasx_xvbitseti_b (_1, 1); ++} ++v16u16 ++__lasx_xvbitseti_h (v16u16 _1) ++{ ++ return __builtin_lasx_xvbitseti_h (_1, 1); ++} ++v8u32 ++__lasx_xvbitseti_w (v8u32 _1) ++{ ++ return __builtin_lasx_xvbitseti_w (_1, 1); ++} ++v4u64 ++__lasx_xvbitseti_d (v4u64 _1) ++{ ++ return __builtin_lasx_xvbitseti_d (_1, 1); ++} ++v32u8 ++__lasx_xvbitrev_b (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvbitrev_b (_1, _2); ++} ++v16u16 ++__lasx_xvbitrev_h (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvbitrev_h (_1, _2); ++} ++v8u32 ++__lasx_xvbitrev_w (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvbitrev_w (_1, _2); ++} ++v4u64 ++__lasx_xvbitrev_d (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvbitrev_d (_1, _2); ++} ++v32u8 ++__lasx_xvbitrevi_b (v32u8 _1) ++{ ++ return __builtin_lasx_xvbitrevi_b (_1, 1); ++} ++v16u16 ++__lasx_xvbitrevi_h (v16u16 _1) ++{ ++ return __builtin_lasx_xvbitrevi_h (_1, 1); ++} ++v8u32 ++__lasx_xvbitrevi_w (v8u32 _1) ++{ ++ return __builtin_lasx_xvbitrevi_w (_1, 1); ++} ++v4u64 ++__lasx_xvbitrevi_d (v4u64 _1) ++{ ++ return __builtin_lasx_xvbitrevi_d (_1, 1); ++} ++v32i8 ++__lasx_xvadd_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvadd_b (_1, _2); ++} ++v16i16 ++__lasx_xvadd_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvadd_h (_1, _2); ++} ++v8i32 ++__lasx_xvadd_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvadd_w (_1, _2); ++} ++v4i64 ++__lasx_xvadd_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvadd_d (_1, _2); ++} ++v32i8 ++__lasx_xvaddi_bu (v32i8 _1) ++{ ++ return __builtin_lasx_xvaddi_bu (_1, 1); ++} ++v16i16 ++__lasx_xvaddi_hu (v16i16 _1) ++{ ++ return __builtin_lasx_xvaddi_hu (_1, 1); ++} ++v8i32 ++__lasx_xvaddi_wu (v8i32 _1) ++{ ++ return __builtin_lasx_xvaddi_wu (_1, 1); ++} ++v4i64 ++__lasx_xvaddi_du (v4i64 _1) ++{ ++ return __builtin_lasx_xvaddi_du (_1, 1); ++} ++v32i8 ++__lasx_xvsub_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsub_b (_1, _2); ++} ++v16i16 ++__lasx_xvsub_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsub_h (_1, _2); ++} ++v8i32 ++__lasx_xvsub_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsub_w (_1, _2); ++} ++v4i64 ++__lasx_xvsub_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsub_d (_1, _2); ++} ++v32i8 ++__lasx_xvsubi_bu (v32i8 _1) ++{ ++ return __builtin_lasx_xvsubi_bu (_1, 1); ++} ++v16i16 ++__lasx_xvsubi_hu (v16i16 _1) ++{ ++ return __builtin_lasx_xvsubi_hu (_1, 1); ++} ++v8i32 ++__lasx_xvsubi_wu (v8i32 _1) ++{ ++ return __builtin_lasx_xvsubi_wu (_1, 1); ++} ++v4i64 ++__lasx_xvsubi_du (v4i64 _1) ++{ ++ return __builtin_lasx_xvsubi_du (_1, 1); ++} ++v32i8 ++__lasx_xvmax_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmax_b (_1, _2); ++} ++v16i16 ++__lasx_xvmax_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmax_h (_1, _2); ++} ++v8i32 ++__lasx_xvmax_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmax_w (_1, _2); ++} ++v4i64 ++__lasx_xvmax_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmax_d (_1, _2); ++} ++v32i8 ++__lasx_xvmaxi_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvmaxi_b (_1, 1); ++} ++v16i16 ++__lasx_xvmaxi_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvmaxi_h (_1, 1); ++} ++v8i32 ++__lasx_xvmaxi_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvmaxi_w (_1, 1); ++} ++v4i64 ++__lasx_xvmaxi_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvmaxi_d (_1, 1); ++} ++v32u8 ++__lasx_xvmax_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvmax_bu (_1, _2); ++} ++v16u16 ++__lasx_xvmax_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvmax_hu (_1, _2); ++} ++v8u32 ++__lasx_xvmax_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvmax_wu (_1, _2); ++} ++v4u64 ++__lasx_xvmax_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvmax_du (_1, _2); ++} ++v32u8 ++__lasx_xvmaxi_bu (v32u8 _1) ++{ ++ return __builtin_lasx_xvmaxi_bu (_1, 1); ++} ++v16u16 ++__lasx_xvmaxi_hu (v16u16 _1) ++{ ++ return __builtin_lasx_xvmaxi_hu (_1, 1); ++} ++v8u32 ++__lasx_xvmaxi_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvmaxi_wu (_1, 1); ++} ++v4u64 ++__lasx_xvmaxi_du (v4u64 _1) ++{ ++ return __builtin_lasx_xvmaxi_du (_1, 1); ++} ++v32i8 ++__lasx_xvmin_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmin_b (_1, _2); ++} ++v16i16 ++__lasx_xvmin_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmin_h (_1, _2); ++} ++v8i32 ++__lasx_xvmin_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmin_w (_1, _2); ++} ++v4i64 ++__lasx_xvmin_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmin_d (_1, _2); ++} ++v32i8 ++__lasx_xvmini_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvmini_b (_1, 1); ++} ++v16i16 ++__lasx_xvmini_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvmini_h (_1, 1); ++} ++v8i32 ++__lasx_xvmini_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvmini_w (_1, 1); ++} ++v4i64 ++__lasx_xvmini_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvmini_d (_1, 1); ++} ++v32u8 ++__lasx_xvmin_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvmin_bu (_1, _2); ++} ++v16u16 ++__lasx_xvmin_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvmin_hu (_1, _2); ++} ++v8u32 ++__lasx_xvmin_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvmin_wu (_1, _2); ++} ++v4u64 ++__lasx_xvmin_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvmin_du (_1, _2); ++} ++v32u8 ++__lasx_xvmini_bu (v32u8 _1) ++{ ++ return __builtin_lasx_xvmini_bu (_1, 1); ++} ++v16u16 ++__lasx_xvmini_hu (v16u16 _1) ++{ ++ return __builtin_lasx_xvmini_hu (_1, 1); ++} ++v8u32 ++__lasx_xvmini_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvmini_wu (_1, 1); ++} ++v4u64 ++__lasx_xvmini_du (v4u64 _1) ++{ ++ return __builtin_lasx_xvmini_du (_1, 1); ++} ++v32i8 ++__lasx_xvseq_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvseq_b (_1, _2); ++} ++v16i16 ++__lasx_xvseq_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvseq_h (_1, _2); ++} ++v8i32 ++__lasx_xvseq_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvseq_w (_1, _2); ++} ++v4i64 ++__lasx_xvseq_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvseq_d (_1, _2); ++} ++v32i8 ++__lasx_xvseqi_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvseqi_b (_1, 1); ++} ++v16i16 ++__lasx_xvseqi_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvseqi_h (_1, 1); ++} ++v8i32 ++__lasx_xvseqi_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvseqi_w (_1, 1); ++} ++v4i64 ++__lasx_xvseqi_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvseqi_d (_1, 1); ++} ++v32i8 ++__lasx_xvslt_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvslt_b (_1, _2); ++} ++v16i16 ++__lasx_xvslt_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvslt_h (_1, _2); ++} ++v8i32 ++__lasx_xvslt_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvslt_w (_1, _2); ++} ++v4i64 ++__lasx_xvslt_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvslt_d (_1, _2); ++} ++v32i8 ++__lasx_xvslti_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvslti_b (_1, 1); ++} ++v16i16 ++__lasx_xvslti_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvslti_h (_1, 1); ++} ++v8i32 ++__lasx_xvslti_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvslti_w (_1, 1); ++} ++v4i64 ++__lasx_xvslti_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvslti_d (_1, 1); ++} ++v32i8 ++__lasx_xvslt_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvslt_bu (_1, _2); ++} ++v16i16 ++__lasx_xvslt_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvslt_hu (_1, _2); ++} ++v8i32 ++__lasx_xvslt_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvslt_wu (_1, _2); ++} ++v4i64 ++__lasx_xvslt_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvslt_du (_1, _2); ++} ++v32i8 ++__lasx_xvslti_bu (v32u8 _1) ++{ ++ return __builtin_lasx_xvslti_bu (_1, 1); ++} ++v16i16 ++__lasx_xvslti_hu (v16u16 _1) ++{ ++ return __builtin_lasx_xvslti_hu (_1, 1); ++} ++v8i32 ++__lasx_xvslti_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvslti_wu (_1, 1); ++} ++v4i64 ++__lasx_xvslti_du (v4u64 _1) ++{ ++ return __builtin_lasx_xvslti_du (_1, 1); ++} ++v32i8 ++__lasx_xvsle_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsle_b (_1, _2); ++} ++v16i16 ++__lasx_xvsle_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsle_h (_1, _2); ++} ++v8i32 ++__lasx_xvsle_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsle_w (_1, _2); ++} ++v4i64 ++__lasx_xvsle_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsle_d (_1, _2); ++} ++v32i8 ++__lasx_xvslei_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvslei_b (_1, 1); ++} ++v16i16 ++__lasx_xvslei_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvslei_h (_1, 1); ++} ++v8i32 ++__lasx_xvslei_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvslei_w (_1, 1); ++} ++v4i64 ++__lasx_xvslei_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvslei_d (_1, 1); ++} ++v32i8 ++__lasx_xvsle_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvsle_bu (_1, _2); ++} ++v16i16 ++__lasx_xvsle_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvsle_hu (_1, _2); ++} ++v8i32 ++__lasx_xvsle_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvsle_wu (_1, _2); ++} ++v4i64 ++__lasx_xvsle_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvsle_du (_1, _2); ++} ++v32i8 ++__lasx_xvslei_bu (v32u8 _1) ++{ ++ return __builtin_lasx_xvslei_bu (_1, 1); ++} ++v16i16 ++__lasx_xvslei_hu (v16u16 _1) ++{ ++ return __builtin_lasx_xvslei_hu (_1, 1); ++} ++v8i32 ++__lasx_xvslei_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvslei_wu (_1, 1); ++} ++v4i64 ++__lasx_xvslei_du (v4u64 _1) ++{ ++ return __builtin_lasx_xvslei_du (_1, 1); ++} ++v32i8 ++__lasx_xvsat_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvsat_b (_1, 1); ++} ++v16i16 ++__lasx_xvsat_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvsat_h (_1, 1); ++} ++v8i32 ++__lasx_xvsat_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvsat_w (_1, 1); ++} ++v4i64 ++__lasx_xvsat_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvsat_d (_1, 1); ++} ++v32u8 ++__lasx_xvsat_bu (v32u8 _1) ++{ ++ return __builtin_lasx_xvsat_bu (_1, 1); ++} ++v16u16 ++__lasx_xvsat_hu (v16u16 _1) ++{ ++ return __builtin_lasx_xvsat_hu (_1, 1); ++} ++v8u32 ++__lasx_xvsat_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvsat_wu (_1, 1); ++} ++v4u64 ++__lasx_xvsat_du (v4u64 _1) ++{ ++ return __builtin_lasx_xvsat_du (_1, 1); ++} ++v32i8 ++__lasx_xvadda_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvadda_b (_1, _2); ++} ++v16i16 ++__lasx_xvadda_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvadda_h (_1, _2); ++} ++v8i32 ++__lasx_xvadda_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvadda_w (_1, _2); ++} ++v4i64 ++__lasx_xvadda_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvadda_d (_1, _2); ++} ++v32i8 ++__lasx_xvsadd_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsadd_b (_1, _2); ++} ++v16i16 ++__lasx_xvsadd_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsadd_h (_1, _2); ++} ++v8i32 ++__lasx_xvsadd_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsadd_w (_1, _2); ++} ++v4i64 ++__lasx_xvsadd_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsadd_d (_1, _2); ++} ++v32u8 ++__lasx_xvsadd_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvsadd_bu (_1, _2); ++} ++v16u16 ++__lasx_xvsadd_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvsadd_hu (_1, _2); ++} ++v8u32 ++__lasx_xvsadd_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvsadd_wu (_1, _2); ++} ++v4u64 ++__lasx_xvsadd_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvsadd_du (_1, _2); ++} ++v32i8 ++__lasx_xvavg_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvavg_b (_1, _2); ++} ++v16i16 ++__lasx_xvavg_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvavg_h (_1, _2); ++} ++v8i32 ++__lasx_xvavg_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvavg_w (_1, _2); ++} ++v4i64 ++__lasx_xvavg_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvavg_d (_1, _2); ++} ++v32u8 ++__lasx_xvavg_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvavg_bu (_1, _2); ++} ++v16u16 ++__lasx_xvavg_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvavg_hu (_1, _2); ++} ++v8u32 ++__lasx_xvavg_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvavg_wu (_1, _2); ++} ++v4u64 ++__lasx_xvavg_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvavg_du (_1, _2); ++} ++v32i8 ++__lasx_xvavgr_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvavgr_b (_1, _2); ++} ++v16i16 ++__lasx_xvavgr_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvavgr_h (_1, _2); ++} ++v8i32 ++__lasx_xvavgr_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvavgr_w (_1, _2); ++} ++v4i64 ++__lasx_xvavgr_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvavgr_d (_1, _2); ++} ++v32u8 ++__lasx_xvavgr_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvavgr_bu (_1, _2); ++} ++v16u16 ++__lasx_xvavgr_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvavgr_hu (_1, _2); ++} ++v8u32 ++__lasx_xvavgr_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvavgr_wu (_1, _2); ++} ++v4u64 ++__lasx_xvavgr_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvavgr_du (_1, _2); ++} ++v32i8 ++__lasx_xvssub_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssub_b (_1, _2); ++} ++v16i16 ++__lasx_xvssub_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssub_h (_1, _2); ++} ++v8i32 ++__lasx_xvssub_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssub_w (_1, _2); ++} ++v4i64 ++__lasx_xvssub_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssub_d (_1, _2); ++} ++v32u8 ++__lasx_xvssub_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvssub_bu (_1, _2); ++} ++v16u16 ++__lasx_xvssub_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvssub_hu (_1, _2); ++} ++v8u32 ++__lasx_xvssub_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvssub_wu (_1, _2); ++} ++v4u64 ++__lasx_xvssub_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvssub_du (_1, _2); ++} ++v32i8 ++__lasx_xvabsd_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvabsd_b (_1, _2); ++} ++v16i16 ++__lasx_xvabsd_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvabsd_h (_1, _2); ++} ++v8i32 ++__lasx_xvabsd_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvabsd_w (_1, _2); ++} ++v4i64 ++__lasx_xvabsd_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvabsd_d (_1, _2); ++} ++v32u8 ++__lasx_xvabsd_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvabsd_bu (_1, _2); ++} ++v16u16 ++__lasx_xvabsd_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvabsd_hu (_1, _2); ++} ++v8u32 ++__lasx_xvabsd_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvabsd_wu (_1, _2); ++} ++v4u64 ++__lasx_xvabsd_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvabsd_du (_1, _2); ++} ++v32i8 ++__lasx_xvmul_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmul_b (_1, _2); ++} ++v16i16 ++__lasx_xvmul_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmul_h (_1, _2); ++} ++v8i32 ++__lasx_xvmul_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmul_w (_1, _2); ++} ++v4i64 ++__lasx_xvmul_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmul_d (_1, _2); ++} ++v32i8 ++__lasx_xvmadd_b (v32i8 _1, v32i8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvmadd_b (_1, _2, _3); ++} ++v16i16 ++__lasx_xvmadd_h (v16i16 _1, v16i16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvmadd_h (_1, _2, _3); ++} ++v8i32 ++__lasx_xvmadd_w (v8i32 _1, v8i32 _2, v8i32 _3) ++{ ++ return __builtin_lasx_xvmadd_w (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmadd_d (v4i64 _1, v4i64 _2, v4i64 _3) ++{ ++ return __builtin_lasx_xvmadd_d (_1, _2, _3); ++} ++v32i8 ++__lasx_xvmsub_b (v32i8 _1, v32i8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvmsub_b (_1, _2, _3); ++} ++v16i16 ++__lasx_xvmsub_h (v16i16 _1, v16i16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvmsub_h (_1, _2, _3); ++} ++v8i32 ++__lasx_xvmsub_w (v8i32 _1, v8i32 _2, v8i32 _3) ++{ ++ return __builtin_lasx_xvmsub_w (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmsub_d (v4i64 _1, v4i64 _2, v4i64 _3) ++{ ++ return __builtin_lasx_xvmsub_d (_1, _2, _3); ++} ++v32i8 ++__lasx_xvdiv_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvdiv_b (_1, _2); ++} ++v16i16 ++__lasx_xvdiv_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvdiv_h (_1, _2); ++} ++v8i32 ++__lasx_xvdiv_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvdiv_w (_1, _2); ++} ++v4i64 ++__lasx_xvdiv_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvdiv_d (_1, _2); ++} ++v32u8 ++__lasx_xvdiv_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvdiv_bu (_1, _2); ++} ++v16u16 ++__lasx_xvdiv_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvdiv_hu (_1, _2); ++} ++v8u32 ++__lasx_xvdiv_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvdiv_wu (_1, _2); ++} ++v4u64 ++__lasx_xvdiv_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvdiv_du (_1, _2); ++} ++v16i16 ++__lasx_xvhaddw_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvhaddw_h_b (_1, _2); ++} ++v8i32 ++__lasx_xvhaddw_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvhaddw_w_h (_1, _2); ++} ++v4i64 ++__lasx_xvhaddw_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvhaddw_d_w (_1, _2); ++} ++v16u16 ++__lasx_xvhaddw_hu_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvhaddw_hu_bu (_1, _2); ++} ++v8u32 ++__lasx_xvhaddw_wu_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvhaddw_wu_hu (_1, _2); ++} ++v4u64 ++__lasx_xvhaddw_du_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvhaddw_du_wu (_1, _2); ++} ++v16i16 ++__lasx_xvhsubw_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvhsubw_h_b (_1, _2); ++} ++v8i32 ++__lasx_xvhsubw_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvhsubw_w_h (_1, _2); ++} ++v4i64 ++__lasx_xvhsubw_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvhsubw_d_w (_1, _2); ++} ++v16i16 ++__lasx_xvhsubw_hu_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvhsubw_hu_bu (_1, _2); ++} ++v8i32 ++__lasx_xvhsubw_wu_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvhsubw_wu_hu (_1, _2); ++} ++v4i64 ++__lasx_xvhsubw_du_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvhsubw_du_wu (_1, _2); ++} ++v32i8 ++__lasx_xvmod_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmod_b (_1, _2); ++} ++v16i16 ++__lasx_xvmod_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmod_h (_1, _2); ++} ++v8i32 ++__lasx_xvmod_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmod_w (_1, _2); ++} ++v4i64 ++__lasx_xvmod_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmod_d (_1, _2); ++} ++v32u8 ++__lasx_xvmod_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvmod_bu (_1, _2); ++} ++v16u16 ++__lasx_xvmod_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvmod_hu (_1, _2); ++} ++v8u32 ++__lasx_xvmod_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvmod_wu (_1, _2); ++} ++v4u64 ++__lasx_xvmod_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvmod_du (_1, _2); ++} ++v32i8 ++__lasx_xvrepl128vei_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvrepl128vei_b (_1, 1); ++} ++v16i16 ++__lasx_xvrepl128vei_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvrepl128vei_h (_1, 1); ++} ++v8i32 ++__lasx_xvrepl128vei_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvrepl128vei_w (_1, 1); ++} ++v4i64 ++__lasx_xvrepl128vei_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvrepl128vei_d (_1, 1); ++} ++v32i8 ++__lasx_xvpickev_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvpickev_b (_1, _2); ++} ++v16i16 ++__lasx_xvpickev_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvpickev_h (_1, _2); ++} ++v8i32 ++__lasx_xvpickev_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvpickev_w (_1, _2); ++} ++v4i64 ++__lasx_xvpickev_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvpickev_d (_1, _2); ++} ++v32i8 ++__lasx_xvpickod_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvpickod_b (_1, _2); ++} ++v16i16 ++__lasx_xvpickod_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvpickod_h (_1, _2); ++} ++v8i32 ++__lasx_xvpickod_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvpickod_w (_1, _2); ++} ++v4i64 ++__lasx_xvpickod_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvpickod_d (_1, _2); ++} ++v32i8 ++__lasx_xvilvh_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvilvh_b (_1, _2); ++} ++v16i16 ++__lasx_xvilvh_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvilvh_h (_1, _2); ++} ++v8i32 ++__lasx_xvilvh_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvilvh_w (_1, _2); ++} ++v4i64 ++__lasx_xvilvh_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvilvh_d (_1, _2); ++} ++v32i8 ++__lasx_xvilvl_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvilvl_b (_1, _2); ++} ++v16i16 ++__lasx_xvilvl_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvilvl_h (_1, _2); ++} ++v8i32 ++__lasx_xvilvl_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvilvl_w (_1, _2); ++} ++v4i64 ++__lasx_xvilvl_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvilvl_d (_1, _2); ++} ++v32i8 ++__lasx_xvpackev_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvpackev_b (_1, _2); ++} ++v16i16 ++__lasx_xvpackev_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvpackev_h (_1, _2); ++} ++v8i32 ++__lasx_xvpackev_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvpackev_w (_1, _2); ++} ++v4i64 ++__lasx_xvpackev_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvpackev_d (_1, _2); ++} ++v32i8 ++__lasx_xvpackod_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvpackod_b (_1, _2); ++} ++v16i16 ++__lasx_xvpackod_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvpackod_h (_1, _2); ++} ++v8i32 ++__lasx_xvpackod_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvpackod_w (_1, _2); ++} ++v4i64 ++__lasx_xvpackod_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvpackod_d (_1, _2); ++} ++v32i8 ++__lasx_xvshuf_b (v32i8 _1, v32i8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvshuf_b (_1, _2, _3); ++} ++v16i16 ++__lasx_xvshuf_h (v16i16 _1, v16i16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvshuf_h (_1, _2, _3); ++} ++v8i32 ++__lasx_xvshuf_w (v8i32 _1, v8i32 _2, v8i32 _3) ++{ ++ return __builtin_lasx_xvshuf_w (_1, _2, _3); ++} ++v4i64 ++__lasx_xvshuf_d (v4i64 _1, v4i64 _2, v4i64 _3) ++{ ++ return __builtin_lasx_xvshuf_d (_1, _2, _3); ++} ++v32u8 ++__lasx_xvand_v (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvand_v (_1, _2); ++} ++v32u8 ++__lasx_xvandi_b (v32u8 _1) ++{ ++ return __builtin_lasx_xvandi_b (_1, 1); ++} ++v32u8 ++__lasx_xvor_v (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvor_v (_1, _2); ++} ++v32u8 ++__lasx_xvori_b (v32u8 _1) ++{ ++ return __builtin_lasx_xvori_b (_1, 1); ++} ++v32u8 ++__lasx_xvnor_v (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvnor_v (_1, _2); ++} ++v32u8 ++__lasx_xvnori_b (v32u8 _1) ++{ ++ return __builtin_lasx_xvnori_b (_1, 1); ++} ++v32u8 ++__lasx_xvxor_v (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvxor_v (_1, _2); ++} ++v32u8 ++__lasx_xvxori_b (v32u8 _1) ++{ ++ return __builtin_lasx_xvxori_b (_1, 1); ++} ++v32u8 ++__lasx_xvbitsel_v (v32u8 _1, v32u8 _2, v32u8 _3) ++{ ++ return __builtin_lasx_xvbitsel_v (_1, _2, _3); ++} ++v32u8 ++__lasx_xvbitseli_b (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvbitseli_b (_1, _2, 1); ++} ++v32i8 ++__lasx_xvshuf4i_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvshuf4i_b (_1, 1); ++} ++v16i16 ++__lasx_xvshuf4i_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvshuf4i_h (_1, 1); ++} ++v8i32 ++__lasx_xvshuf4i_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvshuf4i_w (_1, 1); ++} ++v32i8 ++__lasx_xvreplgr2vr_b (int _1) ++{ ++ return __builtin_lasx_xvreplgr2vr_b (_1); ++} ++v16i16 ++__lasx_xvreplgr2vr_h (int _1) ++{ ++ return __builtin_lasx_xvreplgr2vr_h (_1); ++} ++v8i32 ++__lasx_xvreplgr2vr_w (int _1) ++{ ++ return __builtin_lasx_xvreplgr2vr_w (_1); ++} ++v4i64 ++__lasx_xvreplgr2vr_d (int _1) ++{ ++ return __builtin_lasx_xvreplgr2vr_d (_1); ++} ++v32i8 ++__lasx_xvpcnt_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvpcnt_b (_1); ++} ++v16i16 ++__lasx_xvpcnt_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvpcnt_h (_1); ++} ++v8i32 ++__lasx_xvpcnt_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvpcnt_w (_1); ++} ++v4i64 ++__lasx_xvpcnt_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvpcnt_d (_1); ++} ++v32i8 ++__lasx_xvclo_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvclo_b (_1); ++} ++v16i16 ++__lasx_xvclo_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvclo_h (_1); ++} ++v8i32 ++__lasx_xvclo_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvclo_w (_1); ++} ++v4i64 ++__lasx_xvclo_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvclo_d (_1); ++} ++v32i8 ++__lasx_xvclz_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvclz_b (_1); ++} ++v16i16 ++__lasx_xvclz_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvclz_h (_1); ++} ++v8i32 ++__lasx_xvclz_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvclz_w (_1); ++} ++v4i64 ++__lasx_xvclz_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvclz_d (_1); ++} ++v8f32 ++__lasx_xvfadd_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfadd_s (_1, _2); ++} ++v4f64 ++__lasx_xvfadd_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfadd_d (_1, _2); ++} ++v8f32 ++__lasx_xvfsub_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfsub_s (_1, _2); ++} ++v4f64 ++__lasx_xvfsub_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfsub_d (_1, _2); ++} ++v8f32 ++__lasx_xvfmul_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfmul_s (_1, _2); ++} ++v4f64 ++__lasx_xvfmul_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfmul_d (_1, _2); ++} ++v8f32 ++__lasx_xvfdiv_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfdiv_s (_1, _2); ++} ++v4f64 ++__lasx_xvfdiv_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfdiv_d (_1, _2); ++} ++v16i16 ++__lasx_xvfcvt_h_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcvt_h_s (_1, _2); ++} ++v8f32 ++__lasx_xvfcvt_s_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcvt_s_d (_1, _2); ++} ++v8f32 ++__lasx_xvfmin_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfmin_s (_1, _2); ++} ++v4f64 ++__lasx_xvfmin_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfmin_d (_1, _2); ++} ++v8f32 ++__lasx_xvfmina_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfmina_s (_1, _2); ++} ++v4f64 ++__lasx_xvfmina_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfmina_d (_1, _2); ++} ++v8f32 ++__lasx_xvfmax_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfmax_s (_1, _2); ++} ++v4f64 ++__lasx_xvfmax_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfmax_d (_1, _2); ++} ++v8f32 ++__lasx_xvfmaxa_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfmaxa_s (_1, _2); ++} ++v4f64 ++__lasx_xvfmaxa_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfmaxa_d (_1, _2); ++} ++v8i32 ++__lasx_xvfclass_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfclass_s (_1); ++} ++v4i64 ++__lasx_xvfclass_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfclass_d (_1); ++} ++v8f32 ++__lasx_xvfsqrt_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfsqrt_s (_1); ++} ++v4f64 ++__lasx_xvfsqrt_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfsqrt_d (_1); ++} ++v8f32 ++__lasx_xvfrecip_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfrecip_s (_1); ++} ++v4f64 ++__lasx_xvfrecip_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfrecip_d (_1); ++} ++v8f32 ++__lasx_xvfrint_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfrint_s (_1); ++} ++v4f64 ++__lasx_xvfrint_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfrint_d (_1); ++} ++v8f32 ++__lasx_xvfrsqrt_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfrsqrt_s (_1); ++} ++v4f64 ++__lasx_xvfrsqrt_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfrsqrt_d (_1); ++} ++v8f32 ++__lasx_xvflogb_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvflogb_s (_1); ++} ++v4f64 ++__lasx_xvflogb_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvflogb_d (_1); ++} ++v8f32 ++__lasx_xvfcvth_s_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvfcvth_s_h (_1); ++} ++v4f64 ++__lasx_xvfcvth_d_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfcvth_d_s (_1); ++} ++v8f32 ++__lasx_xvfcvtl_s_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvfcvtl_s_h (_1); ++} ++v4f64 ++__lasx_xvfcvtl_d_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfcvtl_d_s (_1); ++} ++v8i32 ++__lasx_xvftint_w_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftint_w_s (_1); ++} ++v4i64 ++__lasx_xvftint_l_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvftint_l_d (_1); ++} ++v8u32 ++__lasx_xvftint_wu_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftint_wu_s (_1); ++} ++v4u64 ++__lasx_xvftint_lu_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvftint_lu_d (_1); ++} ++v8i32 ++__lasx_xvftintrz_w_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrz_w_s (_1); ++} ++v4i64 ++__lasx_xvftintrz_l_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvftintrz_l_d (_1); ++} ++v8u32 ++__lasx_xvftintrz_wu_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrz_wu_s (_1); ++} ++v4u64 ++__lasx_xvftintrz_lu_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvftintrz_lu_d (_1); ++} ++v8f32 ++__lasx_xvffint_s_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvffint_s_w (_1); ++} ++v4f64 ++__lasx_xvffint_d_l (v4i64 _1) ++{ ++ return __builtin_lasx_xvffint_d_l (_1); ++} ++v8f32 ++__lasx_xvffint_s_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvffint_s_wu (_1); ++} ++v4f64 ++__lasx_xvffint_d_lu (v4u64 _1) ++{ ++ return __builtin_lasx_xvffint_d_lu (_1); ++} ++v32i8 ++__lasx_xvreplve_b (v32i8 _1, int _2) ++{ ++ return __builtin_lasx_xvreplve_b (_1, _2); ++} ++v16i16 ++__lasx_xvreplve_h (v16i16 _1, int _2) ++{ ++ return __builtin_lasx_xvreplve_h (_1, _2); ++} ++v8i32 ++__lasx_xvreplve_w (v8i32 _1, int _2) ++{ ++ return __builtin_lasx_xvreplve_w (_1, _2); ++} ++v4i64 ++__lasx_xvreplve_d (v4i64 _1, int _2) ++{ ++ return __builtin_lasx_xvreplve_d (_1, _2); ++} ++v8i32 ++__lasx_xvpermi_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvpermi_w (_1, _2, 1); ++} ++v32u8 ++__lasx_xvandn_v (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvandn_v (_1, _2); ++} ++v32i8 ++__lasx_xvneg_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvneg_b (_1); ++} ++v16i16 ++__lasx_xvneg_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvneg_h (_1); ++} ++v8i32 ++__lasx_xvneg_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvneg_w (_1); ++} ++v4i64 ++__lasx_xvneg_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvneg_d (_1); ++} ++v32i8 ++__lasx_xvmuh_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmuh_b (_1, _2); ++} ++v16i16 ++__lasx_xvmuh_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmuh_h (_1, _2); ++} ++v8i32 ++__lasx_xvmuh_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmuh_w (_1, _2); ++} ++v4i64 ++__lasx_xvmuh_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmuh_d (_1, _2); ++} ++v32u8 ++__lasx_xvmuh_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvmuh_bu (_1, _2); ++} ++v16u16 ++__lasx_xvmuh_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvmuh_hu (_1, _2); ++} ++v8u32 ++__lasx_xvmuh_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvmuh_wu (_1, _2); ++} ++v4u64 ++__lasx_xvmuh_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvmuh_du (_1, _2); ++} ++v16i16 ++__lasx_xvsllwil_h_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvsllwil_h_b (_1, 1); ++} ++v8i32 ++__lasx_xvsllwil_w_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvsllwil_w_h (_1, 1); ++} ++v4i64 ++__lasx_xvsllwil_d_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvsllwil_d_w (_1, 1); ++} ++v16u16 ++__lasx_xvsllwil_hu_bu (v32u8 _1) ++{ ++ return __builtin_lasx_xvsllwil_hu_bu (_1, 1); ++} ++v8u32 ++__lasx_xvsllwil_wu_hu (v16u16 _1) ++{ ++ return __builtin_lasx_xvsllwil_wu_hu (_1, 1); ++} ++v4u64 ++__lasx_xvsllwil_du_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvsllwil_du_wu (_1, 1); ++} ++v32i8 ++__lasx_xvsran_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsran_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvsran_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsran_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvsran_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsran_w_d (_1, _2); ++} ++v32i8 ++__lasx_xvssran_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssran_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvssran_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssran_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvssran_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssran_w_d (_1, _2); ++} ++v32u8 ++__lasx_xvssran_bu_h (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvssran_bu_h (_1, _2); ++} ++v16u16 ++__lasx_xvssran_hu_w (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvssran_hu_w (_1, _2); ++} ++v8u32 ++__lasx_xvssran_wu_d (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvssran_wu_d (_1, _2); ++} ++v32i8 ++__lasx_xvsrarn_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrarn_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvsrarn_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrarn_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvsrarn_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrarn_w_d (_1, _2); ++} ++v32i8 ++__lasx_xvssrarn_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrarn_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvssrarn_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrarn_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvssrarn_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrarn_w_d (_1, _2); ++} ++v32u8 ++__lasx_xvssrarn_bu_h (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvssrarn_bu_h (_1, _2); ++} ++v16u16 ++__lasx_xvssrarn_hu_w (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvssrarn_hu_w (_1, _2); ++} ++v8u32 ++__lasx_xvssrarn_wu_d (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvssrarn_wu_d (_1, _2); ++} ++v32i8 ++__lasx_xvsrln_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrln_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvsrln_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrln_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvsrln_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrln_w_d (_1, _2); ++} ++v32u8 ++__lasx_xvssrln_bu_h (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvssrln_bu_h (_1, _2); ++} ++v16u16 ++__lasx_xvssrln_hu_w (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvssrln_hu_w (_1, _2); ++} ++v8u32 ++__lasx_xvssrln_wu_d (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvssrln_wu_d (_1, _2); ++} ++v32i8 ++__lasx_xvsrlrn_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrlrn_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvsrlrn_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrlrn_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvsrlrn_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrlrn_w_d (_1, _2); ++} ++v32u8 ++__lasx_xvssrlrn_bu_h (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvssrlrn_bu_h (_1, _2); ++} ++v16u16 ++__lasx_xvssrlrn_hu_w (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvssrlrn_hu_w (_1, _2); ++} ++v8u32 ++__lasx_xvssrlrn_wu_d (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvssrlrn_wu_d (_1, _2); ++} ++v32i8 ++__lasx_xvfrstpi_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvfrstpi_b (_1, _2, 1); ++} ++v16i16 ++__lasx_xvfrstpi_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvfrstpi_h (_1, _2, 1); ++} ++v32i8 ++__lasx_xvfrstp_b (v32i8 _1, v32i8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvfrstp_b (_1, _2, _3); ++} ++v16i16 ++__lasx_xvfrstp_h (v16i16 _1, v16i16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvfrstp_h (_1, _2, _3); ++} ++v4i64 ++__lasx_xvshuf4i_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvshuf4i_d (_1, _2, 1); ++} ++v32i8 ++__lasx_xvbsrl_v (v32i8 _1) ++{ ++ return __builtin_lasx_xvbsrl_v (_1, 1); ++} ++v32i8 ++__lasx_xvbsll_v (v32i8 _1) ++{ ++ return __builtin_lasx_xvbsll_v (_1, 1); ++} ++v32i8 ++__lasx_xvextrins_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvextrins_b (_1, _2, 1); ++} ++v16i16 ++__lasx_xvextrins_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvextrins_h (_1, _2, 1); ++} ++v8i32 ++__lasx_xvextrins_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvextrins_w (_1, _2, 1); ++} ++v4i64 ++__lasx_xvextrins_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvextrins_d (_1, _2, 1); ++} ++v32i8 ++__lasx_xvmskltz_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvmskltz_b (_1); ++} ++v16i16 ++__lasx_xvmskltz_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvmskltz_h (_1); ++} ++v8i32 ++__lasx_xvmskltz_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvmskltz_w (_1); ++} ++v4i64 ++__lasx_xvmskltz_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvmskltz_d (_1); ++} ++v32i8 ++__lasx_xvsigncov_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsigncov_b (_1, _2); ++} ++v16i16 ++__lasx_xvsigncov_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsigncov_h (_1, _2); ++} ++v8i32 ++__lasx_xvsigncov_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsigncov_w (_1, _2); ++} ++v4i64 ++__lasx_xvsigncov_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsigncov_d (_1, _2); ++} ++v8f32 ++__lasx_xvfmadd_s (v8f32 _1, v8f32 _2, v8f32 _3) ++{ ++ return __builtin_lasx_xvfmadd_s (_1, _2, _3); ++} ++v4f64 ++__lasx_xvfmadd_d (v4f64 _1, v4f64 _2, v4f64 _3) ++{ ++ return __builtin_lasx_xvfmadd_d (_1, _2, _3); ++} ++v8f32 ++__lasx_xvfmsub_s (v8f32 _1, v8f32 _2, v8f32 _3) ++{ ++ return __builtin_lasx_xvfmsub_s (_1, _2, _3); ++} ++v4f64 ++__lasx_xvfmsub_d (v4f64 _1, v4f64 _2, v4f64 _3) ++{ ++ return __builtin_lasx_xvfmsub_d (_1, _2, _3); ++} ++v8f32 ++__lasx_xvfnmadd_s (v8f32 _1, v8f32 _2, v8f32 _3) ++{ ++ return __builtin_lasx_xvfnmadd_s (_1, _2, _3); ++} ++v4f64 ++__lasx_xvfnmadd_d (v4f64 _1, v4f64 _2, v4f64 _3) ++{ ++ return __builtin_lasx_xvfnmadd_d (_1, _2, _3); ++} ++v8f32 ++__lasx_xvfnmsub_s (v8f32 _1, v8f32 _2, v8f32 _3) ++{ ++ return __builtin_lasx_xvfnmsub_s (_1, _2, _3); ++} ++v4f64 ++__lasx_xvfnmsub_d (v4f64 _1, v4f64 _2, v4f64 _3) ++{ ++ return __builtin_lasx_xvfnmsub_d (_1, _2, _3); ++} ++v8i32 ++__lasx_xvftintrne_w_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrne_w_s (_1); ++} ++v4i64 ++__lasx_xvftintrne_l_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvftintrne_l_d (_1); ++} ++v8i32 ++__lasx_xvftintrp_w_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrp_w_s (_1); ++} ++v4i64 ++__lasx_xvftintrp_l_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvftintrp_l_d (_1); ++} ++v8i32 ++__lasx_xvftintrm_w_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrm_w_s (_1); ++} ++v4i64 ++__lasx_xvftintrm_l_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvftintrm_l_d (_1); ++} ++v8i32 ++__lasx_xvftint_w_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvftint_w_d (_1, _2); ++} ++v8f32 ++__lasx_xvffint_s_l (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvffint_s_l (_1, _2); ++} ++v8i32 ++__lasx_xvftintrz_w_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvftintrz_w_d (_1, _2); ++} ++v8i32 ++__lasx_xvftintrp_w_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvftintrp_w_d (_1, _2); ++} ++v8i32 ++__lasx_xvftintrm_w_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvftintrm_w_d (_1, _2); ++} ++v8i32 ++__lasx_xvftintrne_w_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvftintrne_w_d (_1, _2); ++} ++v4i64 ++__lasx_xvftinth_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftinth_l_s (_1); ++} ++v4i64 ++__lasx_xvftintl_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintl_l_s (_1); ++} ++v4f64 ++__lasx_xvffinth_d_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvffinth_d_w (_1); ++} ++v4f64 ++__lasx_xvffintl_d_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvffintl_d_w (_1); ++} ++v4i64 ++__lasx_xvftintrzh_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrzh_l_s (_1); ++} ++v4i64 ++__lasx_xvftintrzl_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrzl_l_s (_1); ++} ++v4i64 ++__lasx_xvftintrph_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrph_l_s (_1); ++} ++v4i64 ++__lasx_xvftintrpl_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrpl_l_s (_1); ++} ++v4i64 ++__lasx_xvftintrmh_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrmh_l_s (_1); ++} ++v4i64 ++__lasx_xvftintrml_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrml_l_s (_1); ++} ++v4i64 ++__lasx_xvftintrneh_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrneh_l_s (_1); ++} ++v4i64 ++__lasx_xvftintrnel_l_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvftintrnel_l_s (_1); ++} ++v8f32 ++__lasx_xvfrintrne_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfrintrne_s (_1); ++} ++v4f64 ++__lasx_xvfrintrne_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfrintrne_d (_1); ++} ++v8f32 ++__lasx_xvfrintrz_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfrintrz_s (_1); ++} ++v4f64 ++__lasx_xvfrintrz_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfrintrz_d (_1); ++} ++v8f32 ++__lasx_xvfrintrp_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfrintrp_s (_1); ++} ++v4f64 ++__lasx_xvfrintrp_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfrintrp_d (_1); ++} ++v8f32 ++__lasx_xvfrintrm_s (v8f32 _1) ++{ ++ return __builtin_lasx_xvfrintrm_s (_1); ++} ++v4f64 ++__lasx_xvfrintrm_d (v4f64 _1) ++{ ++ return __builtin_lasx_xvfrintrm_d (_1); ++} ++v32i8 ++__lasx_xvld (void *_1) ++{ ++ return __builtin_lasx_xvld (_1, 1); ++} ++void ++__lasx_xvst (v32i8 _1, void *_2) ++{ ++ return __builtin_lasx_xvst (_1, _2, 1); ++} ++void ++__lasx_xvstelm_b (v32i8 _1, void *_2) ++{ ++ return __builtin_lasx_xvstelm_b (_1, _2, 1, 1); ++} ++void ++__lasx_xvstelm_h (v16i16 _1, void *_2) ++{ ++ return __builtin_lasx_xvstelm_h (_1, _2, 2, 1); ++} ++void ++__lasx_xvstelm_w (v8i32 _1, void *_2) ++{ ++ return __builtin_lasx_xvstelm_w (_1, _2, 4, 1); ++} ++void ++__lasx_xvstelm_d (v4i64 _1, void *_2) ++{ ++ return __builtin_lasx_xvstelm_d (_1, _2, 8, 1); ++} ++v8i32 ++__lasx_xvinsve0_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvinsve0_w (_1, _2, 1); ++} ++v4i64 ++__lasx_xvinsve0_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvinsve0_d (_1, _2, 1); ++} ++v8i32 ++__lasx_xvpickve_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvpickve_w (_1, 1); ++} ++v4i64 ++__lasx_xvpickve_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvpickve_d (_1, 1); ++} ++v32i8 ++__lasx_xvssrlrn_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrlrn_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvssrlrn_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrlrn_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvssrlrn_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrlrn_w_d (_1, _2); ++} ++v32i8 ++__lasx_xvssrln_b_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrln_b_h (_1, _2); ++} ++v16i16 ++__lasx_xvssrln_h_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrln_h_w (_1, _2); ++} ++v8i32 ++__lasx_xvssrln_w_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrln_w_d (_1, _2); ++} ++v32i8 ++__lasx_xvorn_v (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvorn_v (_1, _2); ++} ++v4i64 ++__lasx_xvldi () ++{ ++ return __builtin_lasx_xvldi (1); ++} ++v32i8 ++__lasx_xvldx (void *_1) ++{ ++ return __builtin_lasx_xvldx (_1, 1); ++} ++void ++__lasx_xvstx (v32i8 _1, void *_2) ++{ ++ return __builtin_lasx_xvstx (_1, _2, 1); ++} ++v4u64 ++__lasx_xvextl_qu_du (v4u64 _1) ++{ ++ return __builtin_lasx_xvextl_qu_du (_1); ++} ++v8i32 ++__lasx_xvinsgr2vr_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvinsgr2vr_w (_1, 1, 1); ++} ++v4i64 ++__lasx_xvinsgr2vr_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvinsgr2vr_d (_1, 1, 1); ++} ++v32i8 ++__lasx_xvreplve0_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvreplve0_b (_1); ++} ++v16i16 ++__lasx_xvreplve0_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvreplve0_h (_1); ++} ++v8i32 ++__lasx_xvreplve0_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvreplve0_w (_1); ++} ++v4i64 ++__lasx_xvreplve0_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvreplve0_d (_1); ++} ++v32i8 ++__lasx_xvreplve0_q (v32i8 _1) ++{ ++ return __builtin_lasx_xvreplve0_q (_1); ++} ++v16i16 ++__lasx_vext2xv_h_b (v32i8 _1) ++{ ++ return __builtin_lasx_vext2xv_h_b (_1); ++} ++v8i32 ++__lasx_vext2xv_w_h (v16i16 _1) ++{ ++ return __builtin_lasx_vext2xv_w_h (_1); ++} ++v4i64 ++__lasx_vext2xv_d_w (v8i32 _1) ++{ ++ return __builtin_lasx_vext2xv_d_w (_1); ++} ++v8i32 ++__lasx_vext2xv_w_b (v32i8 _1) ++{ ++ return __builtin_lasx_vext2xv_w_b (_1); ++} ++v4i64 ++__lasx_vext2xv_d_h (v16i16 _1) ++{ ++ return __builtin_lasx_vext2xv_d_h (_1); ++} ++v4i64 ++__lasx_vext2xv_d_b (v32i8 _1) ++{ ++ return __builtin_lasx_vext2xv_d_b (_1); ++} ++v16i16 ++__lasx_vext2xv_hu_bu (v32i8 _1) ++{ ++ return __builtin_lasx_vext2xv_hu_bu (_1); ++} ++v8i32 ++__lasx_vext2xv_wu_hu (v16i16 _1) ++{ ++ return __builtin_lasx_vext2xv_wu_hu (_1); ++} ++v4i64 ++__lasx_vext2xv_du_wu (v8i32 _1) ++{ ++ return __builtin_lasx_vext2xv_du_wu (_1); ++} ++v8i32 ++__lasx_vext2xv_wu_bu (v32i8 _1) ++{ ++ return __builtin_lasx_vext2xv_wu_bu (_1); ++} ++v4i64 ++__lasx_vext2xv_du_hu (v16i16 _1) ++{ ++ return __builtin_lasx_vext2xv_du_hu (_1); ++} ++v4i64 ++__lasx_vext2xv_du_bu (v32i8 _1) ++{ ++ return __builtin_lasx_vext2xv_du_bu (_1); ++} ++v32i8 ++__lasx_xvpermi_q (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvpermi_q (_1, _2, 1); ++} ++v4i64 ++__lasx_xvpermi_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvpermi_d (_1, 1); ++} ++v8i32 ++__lasx_xvperm_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvperm_w (_1, _2); ++} ++v32i8 ++__lasx_xvldrepl_b (void *_1) ++{ ++ return __builtin_lasx_xvldrepl_b (_1, 1); ++} ++v16i16 ++__lasx_xvldrepl_h (void *_1) ++{ ++ return __builtin_lasx_xvldrepl_h (_1, 2); ++} ++v8i32 ++__lasx_xvldrepl_w (void *_1) ++{ ++ return __builtin_lasx_xvldrepl_w (_1, 4); ++} ++v4i64 ++__lasx_xvldrepl_d (void *_1) ++{ ++ return __builtin_lasx_xvldrepl_d (_1, 8); ++} ++int ++__lasx_xvpickve2gr_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvpickve2gr_w (_1, 1); ++} ++unsigned int ++__lasx_xvpickve2gr_wu (v8i32 _1) ++{ ++ return __builtin_lasx_xvpickve2gr_wu (_1, 1); ++} ++long ++__lasx_xvpickve2gr_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvpickve2gr_d (_1, 1); ++} ++unsigned long int ++__lasx_xvpickve2gr_du (v4i64 _1) ++{ ++ return __builtin_lasx_xvpickve2gr_du (_1, 1); ++} ++v4i64 ++__lasx_xvaddwev_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvaddwev_q_d (_1, _2); ++} ++v4i64 ++__lasx_xvaddwev_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvaddwev_d_w (_1, _2); ++} ++v8i32 ++__lasx_xvaddwev_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvaddwev_w_h (_1, _2); ++} ++v16i16 ++__lasx_xvaddwev_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvaddwev_h_b (_1, _2); ++} ++v4i64 ++__lasx_xvaddwev_q_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvaddwev_q_du (_1, _2); ++} ++v4i64 ++__lasx_xvaddwev_d_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvaddwev_d_wu (_1, _2); ++} ++v8i32 ++__lasx_xvaddwev_w_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvaddwev_w_hu (_1, _2); ++} ++v16i16 ++__lasx_xvaddwev_h_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvaddwev_h_bu (_1, _2); ++} ++v4i64 ++__lasx_xvsubwev_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsubwev_q_d (_1, _2); ++} ++v4i64 ++__lasx_xvsubwev_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsubwev_d_w (_1, _2); ++} ++v8i32 ++__lasx_xvsubwev_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsubwev_w_h (_1, _2); ++} ++v16i16 ++__lasx_xvsubwev_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsubwev_h_b (_1, _2); ++} ++v4i64 ++__lasx_xvsubwev_q_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvsubwev_q_du (_1, _2); ++} ++v4i64 ++__lasx_xvsubwev_d_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvsubwev_d_wu (_1, _2); ++} ++v8i32 ++__lasx_xvsubwev_w_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvsubwev_w_hu (_1, _2); ++} ++v16i16 ++__lasx_xvsubwev_h_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvsubwev_h_bu (_1, _2); ++} ++v4i64 ++__lasx_xvmulwev_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmulwev_q_d (_1, _2); ++} ++v4i64 ++__lasx_xvmulwev_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmulwev_d_w (_1, _2); ++} ++v8i32 ++__lasx_xvmulwev_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmulwev_w_h (_1, _2); ++} ++v16i16 ++__lasx_xvmulwev_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmulwev_h_b (_1, _2); ++} ++v4i64 ++__lasx_xvmulwev_q_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvmulwev_q_du (_1, _2); ++} ++v4i64 ++__lasx_xvmulwev_d_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvmulwev_d_wu (_1, _2); ++} ++v8i32 ++__lasx_xvmulwev_w_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvmulwev_w_hu (_1, _2); ++} ++v16i16 ++__lasx_xvmulwev_h_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvmulwev_h_bu (_1, _2); ++} ++v4i64 ++__lasx_xvaddwod_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvaddwod_q_d (_1, _2); ++} ++v4i64 ++__lasx_xvaddwod_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvaddwod_d_w (_1, _2); ++} ++v8i32 ++__lasx_xvaddwod_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvaddwod_w_h (_1, _2); ++} ++v16i16 ++__lasx_xvaddwod_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvaddwod_h_b (_1, _2); ++} ++v4i64 ++__lasx_xvaddwod_q_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvaddwod_q_du (_1, _2); ++} ++v4i64 ++__lasx_xvaddwod_d_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvaddwod_d_wu (_1, _2); ++} ++v8i32 ++__lasx_xvaddwod_w_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvaddwod_w_hu (_1, _2); ++} ++v16i16 ++__lasx_xvaddwod_h_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvaddwod_h_bu (_1, _2); ++} ++v4i64 ++__lasx_xvsubwod_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsubwod_q_d (_1, _2); ++} ++v4i64 ++__lasx_xvsubwod_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsubwod_d_w (_1, _2); ++} ++v8i32 ++__lasx_xvsubwod_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsubwod_w_h (_1, _2); ++} ++v16i16 ++__lasx_xvsubwod_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsubwod_h_b (_1, _2); ++} ++v4i64 ++__lasx_xvsubwod_q_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvsubwod_q_du (_1, _2); ++} ++v4i64 ++__lasx_xvsubwod_d_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvsubwod_d_wu (_1, _2); ++} ++v8i32 ++__lasx_xvsubwod_w_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvsubwod_w_hu (_1, _2); ++} ++v16i16 ++__lasx_xvsubwod_h_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvsubwod_h_bu (_1, _2); ++} ++v4i64 ++__lasx_xvmulwod_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmulwod_q_d (_1, _2); ++} ++v4i64 ++__lasx_xvmulwod_d_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmulwod_d_w (_1, _2); ++} ++v8i32 ++__lasx_xvmulwod_w_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmulwod_w_h (_1, _2); ++} ++v16i16 ++__lasx_xvmulwod_h_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmulwod_h_b (_1, _2); ++} ++v4i64 ++__lasx_xvmulwod_q_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvmulwod_q_du (_1, _2); ++} ++v4i64 ++__lasx_xvmulwod_d_wu (v8u32 _1, v8u32 _2) ++{ ++ return __builtin_lasx_xvmulwod_d_wu (_1, _2); ++} ++v8i32 ++__lasx_xvmulwod_w_hu (v16u16 _1, v16u16 _2) ++{ ++ return __builtin_lasx_xvmulwod_w_hu (_1, _2); ++} ++v16i16 ++__lasx_xvmulwod_h_bu (v32u8 _1, v32u8 _2) ++{ ++ return __builtin_lasx_xvmulwod_h_bu (_1, _2); ++} ++v4i64 ++__lasx_xvaddwev_d_wu_w (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvaddwev_d_wu_w (_1, _2); ++} ++v8i32 ++__lasx_xvaddwev_w_hu_h (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvaddwev_w_hu_h (_1, _2); ++} ++v16i16 ++__lasx_xvaddwev_h_bu_b (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvaddwev_h_bu_b (_1, _2); ++} ++v4i64 ++__lasx_xvmulwev_d_wu_w (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmulwev_d_wu_w (_1, _2); ++} ++v8i32 ++__lasx_xvmulwev_w_hu_h (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmulwev_w_hu_h (_1, _2); ++} ++v16i16 ++__lasx_xvmulwev_h_bu_b (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmulwev_h_bu_b (_1, _2); ++} ++v4i64 ++__lasx_xvaddwod_d_wu_w (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvaddwod_d_wu_w (_1, _2); ++} ++v8i32 ++__lasx_xvaddwod_w_hu_h (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvaddwod_w_hu_h (_1, _2); ++} ++v16i16 ++__lasx_xvaddwod_h_bu_b (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvaddwod_h_bu_b (_1, _2); ++} ++v4i64 ++__lasx_xvmulwod_d_wu_w (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvmulwod_d_wu_w (_1, _2); ++} ++v8i32 ++__lasx_xvmulwod_w_hu_h (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvmulwod_w_hu_h (_1, _2); ++} ++v16i16 ++__lasx_xvmulwod_h_bu_b (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvmulwod_h_bu_b (_1, _2); ++} ++v4i64 ++__lasx_xvhaddw_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvhaddw_q_d (_1, _2); ++} ++v4u64 ++__lasx_xvhaddw_qu_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvhaddw_qu_du (_1, _2); ++} ++v4i64 ++__lasx_xvhsubw_q_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvhsubw_q_d (_1, _2); ++} ++v4u64 ++__lasx_xvhsubw_qu_du (v4u64 _1, v4u64 _2) ++{ ++ return __builtin_lasx_xvhsubw_qu_du (_1, _2); ++} ++v4i64 ++__lasx_xvmaddwev_q_d (v4i64 _1, v4i64 _2, v4i64 _3) ++{ ++ return __builtin_lasx_xvmaddwev_q_d (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmaddwev_d_w (v4i64 _1, v8i32 _2, v8i32 _3) ++{ ++ return __builtin_lasx_xvmaddwev_d_w (_1, _2, _3); ++} ++v8i32 ++__lasx_xvmaddwev_w_h (v8i32 _1, v16i16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvmaddwev_w_h (_1, _2, _3); ++} ++v16i16 ++__lasx_xvmaddwev_h_b (v16i16 _1, v32i8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvmaddwev_h_b (_1, _2, _3); ++} ++v4u64 ++__lasx_xvmaddwev_q_du (v4u64 _1, v4u64 _2, v4u64 _3) ++{ ++ return __builtin_lasx_xvmaddwev_q_du (_1, _2, _3); ++} ++v4u64 ++__lasx_xvmaddwev_d_wu (v4u64 _1, v8u32 _2, v8u32 _3) ++{ ++ return __builtin_lasx_xvmaddwev_d_wu (_1, _2, _3); ++} ++v8u32 ++__lasx_xvmaddwev_w_hu (v8u32 _1, v16u16 _2, v16u16 _3) ++{ ++ return __builtin_lasx_xvmaddwev_w_hu (_1, _2, _3); ++} ++v16u16 ++__lasx_xvmaddwev_h_bu (v16u16 _1, v32u8 _2, v32u8 _3) ++{ ++ return __builtin_lasx_xvmaddwev_h_bu (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmaddwod_q_d (v4i64 _1, v4i64 _2, v4i64 _3) ++{ ++ return __builtin_lasx_xvmaddwod_q_d (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmaddwod_d_w (v4i64 _1, v8i32 _2, v8i32 _3) ++{ ++ return __builtin_lasx_xvmaddwod_d_w (_1, _2, _3); ++} ++v8i32 ++__lasx_xvmaddwod_w_h (v8i32 _1, v16i16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvmaddwod_w_h (_1, _2, _3); ++} ++v16i16 ++__lasx_xvmaddwod_h_b (v16i16 _1, v32i8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvmaddwod_h_b (_1, _2, _3); ++} ++v4u64 ++__lasx_xvmaddwod_q_du (v4u64 _1, v4u64 _2, v4u64 _3) ++{ ++ return __builtin_lasx_xvmaddwod_q_du (_1, _2, _3); ++} ++v4u64 ++__lasx_xvmaddwod_d_wu (v4u64 _1, v8u32 _2, v8u32 _3) ++{ ++ return __builtin_lasx_xvmaddwod_d_wu (_1, _2, _3); ++} ++v8u32 ++__lasx_xvmaddwod_w_hu (v8u32 _1, v16u16 _2, v16u16 _3) ++{ ++ return __builtin_lasx_xvmaddwod_w_hu (_1, _2, _3); ++} ++v16u16 ++__lasx_xvmaddwod_h_bu (v16u16 _1, v32u8 _2, v32u8 _3) ++{ ++ return __builtin_lasx_xvmaddwod_h_bu (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmaddwev_q_du_d (v4i64 _1, v4u64 _2, v4i64 _3) ++{ ++ return __builtin_lasx_xvmaddwev_q_du_d (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmaddwev_d_wu_w (v4i64 _1, v8u32 _2, v8i32 _3) ++{ ++ return __builtin_lasx_xvmaddwev_d_wu_w (_1, _2, _3); ++} ++v8i32 ++__lasx_xvmaddwev_w_hu_h (v8i32 _1, v16u16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvmaddwev_w_hu_h (_1, _2, _3); ++} ++v16i16 ++__lasx_xvmaddwev_h_bu_b (v16i16 _1, v32u8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvmaddwev_h_bu_b (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmaddwod_q_du_d (v4i64 _1, v4u64 _2, v4i64 _3) ++{ ++ return __builtin_lasx_xvmaddwod_q_du_d (_1, _2, _3); ++} ++v4i64 ++__lasx_xvmaddwod_d_wu_w (v4i64 _1, v8u32 _2, v8i32 _3) ++{ ++ return __builtin_lasx_xvmaddwod_d_wu_w (_1, _2, _3); ++} ++v8i32 ++__lasx_xvmaddwod_w_hu_h (v8i32 _1, v16u16 _2, v16i16 _3) ++{ ++ return __builtin_lasx_xvmaddwod_w_hu_h (_1, _2, _3); ++} ++v16i16 ++__lasx_xvmaddwod_h_bu_b (v16i16 _1, v32u8 _2, v32i8 _3) ++{ ++ return __builtin_lasx_xvmaddwod_h_bu_b (_1, _2, _3); ++} ++v32i8 ++__lasx_xvrotr_b (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvrotr_b (_1, _2); ++} ++v16i16 ++__lasx_xvrotr_h (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvrotr_h (_1, _2); ++} ++v8i32 ++__lasx_xvrotr_w (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvrotr_w (_1, _2); ++} ++v4i64 ++__lasx_xvrotr_d (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvrotr_d (_1, _2); ++} ++v4i64 ++__lasx_xvadd_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvadd_q (_1, _2); ++} ++v4i64 ++__lasx_xvsub_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsub_q (_1, _2); ++} ++v4i64 ++__lasx_xvaddwev_q_du_d (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvaddwev_q_du_d (_1, _2); ++} ++v4i64 ++__lasx_xvaddwod_q_du_d (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvaddwod_q_du_d (_1, _2); ++} ++v4i64 ++__lasx_xvmulwev_q_du_d (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmulwev_q_du_d (_1, _2); ++} ++v4i64 ++__lasx_xvmulwod_q_du_d (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvmulwod_q_du_d (_1, _2); ++} ++v32i8 ++__lasx_xvmskgez_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvmskgez_b (_1); ++} ++v32i8 ++__lasx_xvmsknz_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvmsknz_b (_1); ++} ++v16i16 ++__lasx_xvexth_h_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvexth_h_b (_1); ++} ++v8i32 ++__lasx_xvexth_w_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvexth_w_h (_1); ++} ++v4i64 ++__lasx_xvexth_d_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvexth_d_w (_1); ++} ++v4i64 ++__lasx_xvexth_q_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvexth_q_d (_1); ++} ++v16u16 ++__lasx_xvexth_hu_bu (v32u8 _1) ++{ ++ return __builtin_lasx_xvexth_hu_bu (_1); ++} ++v8u32 ++__lasx_xvexth_wu_hu (v16u16 _1) ++{ ++ return __builtin_lasx_xvexth_wu_hu (_1); ++} ++v4u64 ++__lasx_xvexth_du_wu (v8u32 _1) ++{ ++ return __builtin_lasx_xvexth_du_wu (_1); ++} ++v4u64 ++__lasx_xvexth_qu_du (v4u64 _1) ++{ ++ return __builtin_lasx_xvexth_qu_du (_1); ++} ++v32i8 ++__lasx_xvrotri_b (v32i8 _1) ++{ ++ return __builtin_lasx_xvrotri_b (_1, 1); ++} ++v16i16 ++__lasx_xvrotri_h (v16i16 _1) ++{ ++ return __builtin_lasx_xvrotri_h (_1, 1); ++} ++v8i32 ++__lasx_xvrotri_w (v8i32 _1) ++{ ++ return __builtin_lasx_xvrotri_w (_1, 1); ++} ++v4i64 ++__lasx_xvrotri_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvrotri_d (_1, 1); ++} ++v4i64 ++__lasx_xvextl_q_d (v4i64 _1) ++{ ++ return __builtin_lasx_xvextl_q_d (_1); ++} ++v32i8 ++__lasx_xvsrlni_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsrlni_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvsrlni_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrlni_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvsrlni_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrlni_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvsrlni_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrlni_d_q (_1, _2, 1); ++} ++v32i8 ++__lasx_xvsrlrni_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsrlrni_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvsrlrni_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrlrni_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvsrlrni_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrlrni_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvsrlrni_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrlrni_d_q (_1, _2, 1); ++} ++v32i8 ++__lasx_xvssrlni_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrlni_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvssrlni_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrlni_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvssrlni_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrlni_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvssrlni_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrlni_d_q (_1, _2, 1); ++} ++v32u8 ++__lasx_xvssrlni_bu_h (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrlni_bu_h (_1, _2, 1); ++} ++v16u16 ++__lasx_xvssrlni_hu_w (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrlni_hu_w (_1, _2, 1); ++} ++v8u32 ++__lasx_xvssrlni_wu_d (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrlni_wu_d (_1, _2, 1); ++} ++v4u64 ++__lasx_xvssrlni_du_q (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrlni_du_q (_1, _2, 1); ++} ++v32i8 ++__lasx_xvssrlrni_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrlrni_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvssrlrni_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrlrni_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvssrlrni_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrlrni_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvssrlrni_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrlrni_d_q (_1, _2, 1); ++} ++v32u8 ++__lasx_xvssrlrni_bu_h (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrlrni_bu_h (_1, _2, 1); ++} ++v16u16 ++__lasx_xvssrlrni_hu_w (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrlrni_hu_w (_1, _2, 1); ++} ++v8u32 ++__lasx_xvssrlrni_wu_d (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrlrni_wu_d (_1, _2, 1); ++} ++v4u64 ++__lasx_xvssrlrni_du_q (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrlrni_du_q (_1, _2, 1); ++} ++v32i8 ++__lasx_xvsrani_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsrani_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvsrani_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrani_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvsrani_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrani_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvsrani_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrani_d_q (_1, _2, 1); ++} ++v32i8 ++__lasx_xvsrarni_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvsrarni_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvsrarni_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvsrarni_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvsrarni_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvsrarni_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvsrarni_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvsrarni_d_q (_1, _2, 1); ++} ++v32i8 ++__lasx_xvssrani_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrani_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvssrani_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrani_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvssrani_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrani_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvssrani_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrani_d_q (_1, _2, 1); ++} ++v32u8 ++__lasx_xvssrani_bu_h (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrani_bu_h (_1, _2, 1); ++} ++v16u16 ++__lasx_xvssrani_hu_w (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrani_hu_w (_1, _2, 1); ++} ++v8u32 ++__lasx_xvssrani_wu_d (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrani_wu_d (_1, _2, 1); ++} ++v4u64 ++__lasx_xvssrani_du_q (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrani_du_q (_1, _2, 1); ++} ++v32i8 ++__lasx_xvssrarni_b_h (v32i8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrarni_b_h (_1, _2, 1); ++} ++v16i16 ++__lasx_xvssrarni_h_w (v16i16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrarni_h_w (_1, _2, 1); ++} ++v8i32 ++__lasx_xvssrarni_w_d (v8i32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrarni_w_d (_1, _2, 1); ++} ++v4i64 ++__lasx_xvssrarni_d_q (v4i64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrarni_d_q (_1, _2, 1); ++} ++v32u8 ++__lasx_xvssrarni_bu_h (v32u8 _1, v32i8 _2) ++{ ++ return __builtin_lasx_xvssrarni_bu_h (_1, _2, 1); ++} ++v16u16 ++__lasx_xvssrarni_hu_w (v16u16 _1, v16i16 _2) ++{ ++ return __builtin_lasx_xvssrarni_hu_w (_1, _2, 1); ++} ++v8u32 ++__lasx_xvssrarni_wu_d (v8u32 _1, v8i32 _2) ++{ ++ return __builtin_lasx_xvssrarni_wu_d (_1, _2, 1); ++} ++v4u64 ++__lasx_xvssrarni_du_q (v4u64 _1, v4i64 _2) ++{ ++ return __builtin_lasx_xvssrarni_du_q (_1, _2, 1); ++} ++int ++__lasx_xbnz_b (v32u8 _1) ++{ ++ return __builtin_lasx_xbnz_b (_1); ++} ++int ++__lasx_xbnz_d (v4u64 _1) ++{ ++ return __builtin_lasx_xbnz_d (_1); ++} ++int ++__lasx_xbnz_h (v16u16 _1) ++{ ++ return __builtin_lasx_xbnz_h (_1); ++} ++int ++__lasx_xbnz_v (v32u8 _1) ++{ ++ return __builtin_lasx_xbnz_v (_1); ++} ++int ++__lasx_xbnz_w (v8u32 _1) ++{ ++ return __builtin_lasx_xbnz_w (_1); ++} ++int ++__lasx_xbz_b (v32u8 _1) ++{ ++ return __builtin_lasx_xbz_b (_1); ++} ++int ++__lasx_xbz_d (v4u64 _1) ++{ ++ return __builtin_lasx_xbz_d (_1); ++} ++int ++__lasx_xbz_h (v16u16 _1) ++{ ++ return __builtin_lasx_xbz_h (_1); ++} ++int ++__lasx_xbz_v (v32u8 _1) ++{ ++ return __builtin_lasx_xbz_v (_1); ++} ++int ++__lasx_xbz_w (v8u32 _1) ++{ ++ return __builtin_lasx_xbz_w (_1); ++} ++v4i64 ++__lasx_xvfcmp_caf_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_caf_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_caf_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_caf_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_ceq_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_ceq_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_ceq_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_ceq_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cle_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cle_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cle_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cle_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_clt_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_clt_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_clt_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_clt_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cne_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cne_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cne_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cne_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cor_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cor_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cor_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cor_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cueq_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cueq_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cueq_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cueq_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cule_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cule_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cule_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cule_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cult_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cult_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cult_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cult_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cun_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cun_d (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_cune_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_cune_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cune_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cune_s (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_cun_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_cun_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_saf_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_saf_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_saf_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_saf_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_seq_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_seq_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_seq_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_seq_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sle_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sle_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sle_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sle_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_slt_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_slt_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_slt_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_slt_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sne_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sne_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sne_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sne_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sor_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sor_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sor_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sor_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sueq_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sueq_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sueq_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sueq_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sule_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sule_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sule_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sule_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sult_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sult_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sult_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sult_s (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sun_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sun_d (_1, _2); ++} ++v4i64 ++__lasx_xvfcmp_sune_d (v4f64 _1, v4f64 _2) ++{ ++ return __builtin_lasx_xvfcmp_sune_d (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sune_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sune_s (_1, _2); ++} ++v8i32 ++__lasx_xvfcmp_sun_s (v8f32 _1, v8f32 _2) ++{ ++ return __builtin_lasx_xvfcmp_sun_s (_1, _2); ++} ++v4f64 ++__lasx_xvpickve_d_f (v4f64 _1) ++{ ++ return __builtin_lasx_xvpickve_d_f (_1, 1); ++} ++v8f32 ++__lasx_xvpickve_w_f (v8f32 _1) ++{ ++ return __builtin_lasx_xvpickve_w_f (_1, 1); ++} ++v32i8 ++__lasx_xvrepli_b () ++{ ++ return __builtin_lasx_xvrepli_b (1); ++} ++v4i64 ++__lasx_xvrepli_d () ++{ ++ return __builtin_lasx_xvrepli_d (1); ++} ++v16i16 ++__lasx_xvrepli_h () ++{ ++ return __builtin_lasx_xvrepli_h (1); ++} ++v8i32 ++__lasx_xvrepli_w () ++{ ++ return __builtin_lasx_xvrepli_w (1); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-comparison-and-se.patch
Added
@@ -0,0 +1,5363 @@ +From 9ccb5fcabdf69160eb360da7eab06a207f59334c Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:11:04 +0800 +Subject: PATCH 113/124 LoongArch: Add tests for ASX vector comparison and + selection instruction. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvseq.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvseqi.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsle-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsle-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvslei-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvslei-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvslt-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvslt-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvslti-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvslti-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvseq.c | 650 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvseqi.c | 449 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvsle-1.c | 575 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsle-2.c | 590 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvslei-1.c | 515 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvslei-2.c | 438 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvslt-1.c | 455 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvslt-2.c | 620 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvslti-1.c | 548 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvslti-2.c | 416 +++++++++++ + 10 files changed, 5256 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseq.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseqi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseq.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseq.c +new file mode 100644 +index 000000000..2a42386ce +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseq.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100020001; ++ *((unsigned long *)&__m256i_op00) = 0x0000fffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0xffff000000010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000095120000; ++ *((unsigned long *)&__m256i_op11) = 0xc9da000063f50000; ++ *((unsigned long *)&__m256i_op10) = 0xc7387fff6bbfffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7f0000007f000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7f0000007f000000; ++ *((unsigned long *)&__m256i_op13) = 0x1555156a1555156a; ++ *((unsigned long *)&__m256i_op12) = 0x1555156a1555156a; ++ *((unsigned long *)&__m256i_op11) = 0x1555156a1555156a; ++ *((unsigned long *)&__m256i_op10) = 0x1555156a1555156a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6100000800060005; ++ *((unsigned long *)&__m256i_op02) = 0x5ee1c073b800c916; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5ff00007fff9fff3; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0209fefb08140000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256i_result3) = 0x00ffff00ff000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffffefd; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffefd; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op02) = 0xfffcf800fffcf800; ++ *((unsigned long *)&__m256i_op01) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op00) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffff00fffffff0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00fffffff0; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op02) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op01) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op00) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000005be55bd2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffcc8000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007dfdff4b; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op11) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_result3) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ff00ff00; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff00ffffff00; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ff00ff00; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4ffc3f783fc040c0; ++ *((unsigned long *)&__m256i_op02) = 0x3fc03f803fc040c0; ++ *((unsigned long *)&__m256i_op01) = 0x4ffc3f783fc040c0; ++ *((unsigned long *)&__m256i_op00) = 0x3fc03f803fc040c0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffee0000004c0000; ++ *((unsigned long *)&__m256i_op02) = 0xff050000ff3c0000; ++ *((unsigned long *)&__m256i_op01) = 0x00f9000000780000; ++ *((unsigned long *)&__m256i_op00) = 0xffa80000ff310000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8011ffee804c004c; ++ *((unsigned long *)&__m256i_op12) = 0x00faff0500c3ff3c; ++ *((unsigned long *)&__m256i_op11) = 0x80f900f980780078; ++ *((unsigned long *)&__m256i_op10) = 0x0057ffa800ceff31; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result2) = 0xff000000ff000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m256i_result0) = 0xff000000ff000000; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op12) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op11) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op10) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op12) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op10) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000077fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000000000; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000005500000000; ++ *((unsigned long *)&__m256i_op12) = 0x0001005500020000; ++ *((unsigned long *)&__m256i_op11) = 0x0000005500000000; ++ *((unsigned long *)&__m256i_op10) = 0x0001005500020000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffefff7f00100080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffefff7f00100080; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff01fb0408; ++ *((unsigned long *)&__m256i_op12) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff01fb0408; ++ *((unsigned long *)&__m256i_op10) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffff00ffffffff; ++ __m256i_out = __lasx_xvseq_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0080000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0080000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000501ffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000701ffffce; ++ *((unsigned long *)&__m256i_op01) = 0x0000000501ffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000701ffffce; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000260a378; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000d02317; ++ *((unsigned long *)&__m256i_op01) = 0x000000000260a378; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000d02317; ++ *((unsigned long *)&__m256i_op13) = 0x003f020001400200; ++ *((unsigned long *)&__m256i_op12) = 0x003f00ff003f00c4; ++ *((unsigned long *)&__m256i_op11) = 0x003f020001400200; ++ *((unsigned long *)&__m256i_op10) = 0x003f00ff003f00c4; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseq_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseqi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseqi.c +new file mode 100644 +index 000000000..5478d19c1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvseqi.c +@@ -0,0 +1,449 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffdfe; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffdfe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_d (__m256i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_op02) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_op01) = 0x00b200b300800080; ++ *((unsigned long *)&__m256i_op00) = 0x00b200b300800080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_d (__m256i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_d (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x00197d3200197d56; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x00197d3200197d56; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_h (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000bdfef907bc; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000bdfef907bc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_d (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_b (__m256i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_d (__m256i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_d (__m256i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x800fffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x800fffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x800fffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x800fffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvseqi_w (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-1.c +new file mode 100644 +index 000000000..ed752df00 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-1.c +@@ -0,0 +1,575 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000460086; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007f0079; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000f30028; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000df00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0xbf28b0686066be60; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffff00ffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff00ff00; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ffffff00ff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00ffffffffffffff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op02) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op01) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op00) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op02) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op01) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op00) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff00ff00ffff00; ++ *((unsigned long *)&__m256i_result2) = 0xff000000ff00ff00; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffff00ffff; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000ff00ff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xff00ffffff00ffff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffbfffa0ffffff80; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffbfffa0ffffff80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xbfffa004fffd8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xbfffa004fffd8000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ffff0000ff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ffff0000ff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op02) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op00) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffee; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffee; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op13) = 0xffdfff80ffdfff80; ++ *((unsigned long *)&__m256i_op12) = 0xffdfff80ffdfff80; ++ *((unsigned long *)&__m256i_op11) = 0xffdfff80ffdfff80; ++ *((unsigned long *)&__m256i_op10) = 0xffdfff80ffdfff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff00; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff00ffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xff00ffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00ffffffffffffff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffffffffffff; ++ __m256i_out = __lasx_xvsle_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op02) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op01) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op00) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op13) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op12) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op11) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op10) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fef7fef7fef7fef; ++ *((unsigned long *)&__m256i_op02) = 0x7fef7fef7fef7fef; ++ *((unsigned long *)&__m256i_op01) = 0x7fef7fef7fef7fef; ++ *((unsigned long *)&__m256i_op00) = 0x7fef7fef7fef7fef; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x2aaaaa85aaaaaa85; ++ *((unsigned long *)&__m256i_op12) = 0x2aaa48f4aaaa48f4; ++ *((unsigned long *)&__m256i_op11) = 0x2aaaaa85aaaaaa85; ++ *((unsigned long *)&__m256i_op10) = 0x2aaa48f4aaaa48f4; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvsle_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000900000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000900000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000083f95466; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101010100005400; ++ *((unsigned long *)&__m256i_op13) = 0x007f00f8ff7fff80; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fff6a9d8; ++ *((unsigned long *)&__m256i_op11) = 0x007f00f8ff7fff80; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fff6a9d8; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fe0100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fe0100000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x00197d3200197d56; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x00197d3200197d56; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ffe0001fffe0001; ++ *((unsigned long *)&__m256i_op02) = 0x7ffe0001fffeffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000fdfdfe; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op12) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op12) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op11) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op10) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00f7000000f70007; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00f7000000f70007; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff01fffe00000001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op01) = 0xff01fffe00000001; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op13) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op12) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op11) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op10) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000002d; ++ *((unsigned long *)&__m256i_op02) = 0xc02dc02dc02dc02d; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000002d; ++ *((unsigned long *)&__m256i_op00) = 0xc02dc02dc02dc02d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-2.c +new file mode 100644 +index 000000000..bc98b41af +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsle-2.c +@@ -0,0 +1,590 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op12) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_op11) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op10) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256i_op02) = 0x001fe020001fe020; ++ *((unsigned long *)&__m256i_op01) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256i_op00) = 0x001fe020001fe020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvsle_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op02) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_op01) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op00) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8011ffae800c000c; ++ *((unsigned long *)&__m256i_op02) = 0x00baff050083ff3c; ++ *((unsigned long *)&__m256i_op01) = 0x80b900b980380038; ++ *((unsigned long *)&__m256i_op00) = 0x0017ffa8008eff31; ++ *((unsigned long *)&__m256i_op13) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op12) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op11) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op10) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_result3) = 0xffff0000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256i_op13) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op12) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op10) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000003ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000003ff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x05ea05ea05ea05ec; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x05ea05ea05ea05ec; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000feb60000b7d0; ++ *((unsigned long *)&__m256i_op02) = 0x0000feb60000c7eb; ++ *((unsigned long *)&__m256i_op01) = 0x0000feb60000b7d0; ++ *((unsigned long *)&__m256i_op00) = 0x0000feb60000c7eb; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff010ff0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff010ff0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb683007ffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c0df5b41cf; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb683007ffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c0df5b41cf; ++ *((unsigned long *)&__m256i_op13) = 0x0001497c98ea4fca; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0001497c98ea4fca; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010102; ++ *((unsigned long *)&__m256i_op02) = 0x0101010201010204; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010102; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010102; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00020421d7d41124; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00020421d7d41124; ++ *((unsigned long *)&__m256i_op13) = 0x8000000180007f7f; ++ *((unsigned long *)&__m256i_op12) = 0xffffafaf80000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000180007f7f; ++ *((unsigned long *)&__m256i_op10) = 0xffffafaf80000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_op12) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_op11) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_op10) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op02) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op00) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x94d7fb5200000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op12) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op11) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op10) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op12) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_op11) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op10) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsle_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-1.c +new file mode 100644 +index 000000000..06717802c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-1.c +@@ -0,0 +1,515 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000101ff01; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op02) = 0x00010013000100fe; ++ *((unsigned long *)&__m256i_op01) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op00) = 0x00010013000100fb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_b (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x014200c200c200ae; ++ *((unsigned long *)&__m256i_op02) = 0x014200c200c200ae; ++ *((unsigned long *)&__m256i_op01) = 0x014200c200c200ae; ++ *((unsigned long *)&__m256i_op00) = 0x014200c200c200ae; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffff8900000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffff8900000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff000000000000; ++ __m256i_out = __lasx_xvslei_h (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000460086; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007f0079; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000f30028; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000df00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfc2f3183ef7ffff7; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, 8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100800000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1828f0e09bad7249; ++ *((unsigned long *)&__m256i_op02) = 0x07ffc1b723953cec; ++ *((unsigned long *)&__m256i_op01) = 0x61f2e9b333aab104; ++ *((unsigned long *)&__m256i_op00) = 0x6bf742aa0d7856a0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op02) = 0xc6c6c6c68787878a; ++ *((unsigned long *)&__m256i_op01) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op00) = 0x8787878a00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_d (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-2.c +new file mode 100644 +index 000000000..093d5640e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslei-2.c +@@ -0,0 +1,438 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op02) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op01) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op00) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffff00; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x04e8296f3c611818; ++ *((unsigned long *)&__m256i_op02) = 0x032eafee29010000; ++ *((unsigned long *)&__m256i_op01) = 0x04e8296f3c611818; ++ *((unsigned long *)&__m256i_op00) = 0x032eafee29010000; ++ *((unsigned long *)&__m256i_result3) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000ffffff; ++ *((unsigned long *)&__m256i_result1) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000ffffff; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000f788f788; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000f788f788; ++ *((unsigned long *)&__m256i_result3) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslei_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00217f19ffde80e6; ++ *((unsigned long *)&__m256i_op02) = 0x00037f94fffc806b; ++ *((unsigned long *)&__m256i_op01) = 0x00217f19ffde80e6; ++ *((unsigned long *)&__m256i_op00) = 0x00037f94fffc806b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff000000000000; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op02) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op01) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op00) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op02) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_op01) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op00) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f807f80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f807f80; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_hu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_op02) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_op01) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_op00) = 0xff874dc687870000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op02) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_op01) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op00) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000007ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000007ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x03802fc000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x03802fc000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_wu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_du (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x0001ffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_du (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_du (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslei_du (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslei_du (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-1.c +new file mode 100644 +index 000000000..ca1f5e94f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-1.c +@@ -0,0 +1,455 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvslt_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op02) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op01) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op00) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ff000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ff000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvslt_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000002000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000002000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff0000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff0000ffffffff; ++ __m256i_out = __lasx_xvslt_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000860601934; ++ *((unsigned long *)&__m256i_op12) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op11) = 0x0000000860601934; ++ *((unsigned long *)&__m256i_op10) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op02) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op00) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvslt_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000003fffc0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000003fffc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffffffff; ++ __m256i_out = __lasx_xvslt_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000022222221; ++ *((unsigned long *)&__m256i_op02) = 0x3dddddddfbbb3bbc; ++ *((unsigned long *)&__m256i_op01) = 0x0000000022222221; ++ *((unsigned long *)&__m256i_op00) = 0x3dddddddfbbb3bbc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvslt_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvslt_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op01) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_op12) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_op11) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_op10) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf7f8f7f8f7f8f7f8; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xf7f8f7f8f7f8f7f8; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0df9f8e; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe0df9f8e; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffe0df9f8e; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffe0df9f8e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-2.c +new file mode 100644 +index 000000000..6864f5eb8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslt-2.c +@@ -0,0 +1,620 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x1828f0e09bad7249; ++ *((unsigned long *)&__m256i_op02) = 0x07ffc1b723953cec; ++ *((unsigned long *)&__m256i_op01) = 0x61f2e9b333aab104; ++ *((unsigned long *)&__m256i_op00) = 0x6bf742aa0d7856a0; ++ *((unsigned long *)&__m256i_op13) = 0x0d41c9a7bdd239a7; ++ *((unsigned long *)&__m256i_op12) = 0x0b025d0ef8fdf987; ++ *((unsigned long *)&__m256i_op11) = 0x002944f92da5a708; ++ *((unsigned long *)&__m256i_op10) = 0x038cf4ea999922ef; ++ *((unsigned long *)&__m256i_result3) = 0x00ff0000ffff00ff; ++ *((unsigned long *)&__m256i_result2) = 0xff000000ffffff00; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffffffff00ff; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000017000000080; ++ *((unsigned long *)&__m256i_op02) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op01) = 0x0000017000000080; ++ *((unsigned long *)&__m256i_op00) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256i_op12) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffff8d9ffa7103d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdb801b6d0962003f; ++ *((unsigned long *)&__m256i_op02) = 0xdb8a3109fe0f0024; ++ *((unsigned long *)&__m256i_op01) = 0x9a7f997fff01ffff; ++ *((unsigned long *)&__m256i_op00) = 0xbe632a4f1c3c5653; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00ff0000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_op02) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_op00) = 0x0000000500000005; ++ *((unsigned long *)&__m256i_op13) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op12) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op11) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op10) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202031; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020202031; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op13) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op12) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op13) = 0x5252525252525252; ++ *((unsigned long *)&__m256i_op12) = 0x5252525252525252; ++ *((unsigned long *)&__m256i_op11) = 0x5252525252525252; ++ *((unsigned long *)&__m256i_op10) = 0x5252525252525252; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000040b200002fd4; ++ *((unsigned long *)&__m256i_op02) = 0x00007fff0000739c; ++ *((unsigned long *)&__m256i_op01) = 0x000040b200002fd4; ++ *((unsigned long *)&__m256i_op00) = 0x00007fff0000739c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op13) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffe40; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvslt_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op11) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvslt_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbc74c3d108e05422; ++ *((unsigned long *)&__m256i_op02) = 0xbc1e3e6a5cace67c; ++ *((unsigned long *)&__m256i_op01) = 0xbc74c3d108e0544a; ++ *((unsigned long *)&__m256i_op00) = 0xbc18e696a86565f4; ++ *((unsigned long *)&__m256i_op13) = 0xbc74c3d108e05422; ++ *((unsigned long *)&__m256i_op12) = 0xbc1e3e6a5cace67c; ++ *((unsigned long *)&__m256i_op11) = 0xbc74c3d108e0544a; ++ *((unsigned long *)&__m256i_op10) = 0xbc18e696a86565f4; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x43ef87878000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x43ef87878000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op12) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op10) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslt_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000001400000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000001400000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000017f00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00007f7f03030000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslt_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op12) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op11) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op10) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op02) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op00) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_op13) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op12) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_op11) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op10) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100008000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100007fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100008000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100007fff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000003fbfc04; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001fdfe02; ++ *((unsigned long *)&__m256i_op11) = 0x0000000003fbfc04; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001fdfe02; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0010511c54440437; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0010511c54440437; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffff00ffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00ffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslt_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-1.c +new file mode 100644 +index 000000000..7dd2778a5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-1.c +@@ -0,0 +1,548 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_b (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op02) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe05fc47b400; ++ *((unsigned long *)&__m256i_op02) = 0xfffffe06003fc000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe05fc47b400; ++ *((unsigned long *)&__m256i_op00) = 0xfffffe06003fc000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff02000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff02000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_h (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc58a0a0a07070706; ++ *((unsigned long *)&__m256i_op02) = 0x006b60e4180b0023; ++ *((unsigned long *)&__m256i_op01) = 0x1b39153f334b966a; ++ *((unsigned long *)&__m256i_op00) = 0xf1d75d79efcac002; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff90ff81; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff90ff81; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000045000d0005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000045000d0005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op02) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op00) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op02) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_op01) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op00) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000004efffe00; ++ *((unsigned long *)&__m256i_op02) = 0x0000000047000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000004efffe00; ++ *((unsigned long *)&__m256i_op00) = 0x0000000047000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_w (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x80000000001529c1; ++ *((unsigned long *)&__m256i_op02) = 0x80007073cadc3779; ++ *((unsigned long *)&__m256i_op01) = 0x80000000001529c1; ++ *((unsigned long *)&__m256i_op00) = 0x80007073cadc3779; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op02) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_op01) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op00) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_d (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-2.c +new file mode 100644 +index 000000000..d93e4314e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslti-2.c +@@ -0,0 +1,416 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op02) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op00) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xff00ff00ff00ff00; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_bu (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_hu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffffffffffff; ++ __m256i_out = __lasx_xvslti_hu (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_hu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_hu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffb3b4; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff5ffff4738; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffb3b4; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff5ffff4738; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_hu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvslti_hu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_op02) = 0x007f007f0081007f; ++ *((unsigned long *)&__m256i_op01) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_op00) = 0x007f007f0081007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op02) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000e0e0e0e0; ++ *((unsigned long *)&__m256i_op00) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvslti_wu (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007773; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000003373; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvslti_du (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-floating-point-co.patch
Added
@@ -0,0 +1,7291 @@ +From 5a014f35ac194402adc08945480da44e2c0a772a Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:06:04 +0800 +Subject: PATCH 112/124 LoongArch: Add tests for ASX vector floating-point + conversion instruction. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvfcvt.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcvth.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvffint-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvffint-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvffinth.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfrint_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfrint_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvftint-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvftint-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvftint-3.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvftintl.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvfcvt.c | 528 ++++++ + .../loongarch/vector/lasx/lasx-xvfcvth.c | 485 +++++ + .../loongarch/vector/lasx/lasx-xvffint-1.c | 375 ++++ + .../loongarch/vector/lasx/lasx-xvffint-2.c | 246 +++ + .../loongarch/vector/lasx/lasx-xvffinth.c | 262 +++ + .../loongarch/vector/lasx/lasx-xvfrint_d.c | 429 +++++ + .../loongarch/vector/lasx/lasx-xvfrint_s.c | 723 ++++++++ + .../loongarch/vector/lasx/lasx-xvftint-1.c | 471 +++++ + .../loongarch/vector/lasx/lasx-xvftint-2.c | 1565 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvftint-3.c | 511 ++++++ + .../loongarch/vector/lasx/lasx-xvftintl.c | 1580 +++++++++++++++++ + 11 files changed, 7175 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvt.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvth.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffinth.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftintl.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvt.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvt.c +new file mode 100644 +index 000000000..116399a7c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvt.c +@@ -0,0 +1,528 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000003; ++ *((int *)&__m256_op16) = 0x0000000c; ++ *((int *)&__m256_op15) = 0x00000011; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000005; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000008; ++ *((int *)&__m256_op10) = 0x00000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x6d6d6d6d; ++ *((int *)&__m256_op06) = 0x6d6d6d6d; ++ *((int *)&__m256_op05) = 0x6d6d6d6d; ++ *((int *)&__m256_op04) = 0x6d6d6d6d; ++ *((int *)&__m256_op03) = 0x6d6d6d6d; ++ *((int *)&__m256_op02) = 0x6d6d6d6d; ++ *((int *)&__m256_op01) = 0x6d6d6d6d; ++ *((int *)&__m256_op00) = 0x6d6d6d6d; ++ *((int *)&__m256_op17) = 0x6d6d6d6d; ++ *((int *)&__m256_op16) = 0x6d6d6d6d; ++ *((int *)&__m256_op15) = 0x6d6d6d6d; ++ *((int *)&__m256_op14) = 0x6d6d6d6d; ++ *((int *)&__m256_op13) = 0x6d6d6d6d; ++ *((int *)&__m256_op12) = 0x6d6d6d6d; ++ *((int *)&__m256_op11) = 0x6d6d6d6d; ++ *((int *)&__m256_op10) = 0x6d6d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_result2) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_result1) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_result0) = 0x7c007c007c007c00; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00020000; ++ *((int *)&__m256_op16) = 0x00020000; ++ *((int *)&__m256_op15) = 0x00020000; ++ *((int *)&__m256_op14) = 0x00010000; ++ *((int *)&__m256_op13) = 0x00020000; ++ *((int *)&__m256_op12) = 0x00020000; ++ *((int *)&__m256_op11) = 0x00020000; ++ *((int *)&__m256_op10) = 0x00010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x71717171; ++ *((int *)&__m256_op16) = 0x71010101; ++ *((int *)&__m256_op15) = 0x8e8e8e8e; ++ *((int *)&__m256_op14) = 0x8f00ffff; ++ *((int *)&__m256_op13) = 0x71717171; ++ *((int *)&__m256_op12) = 0x71010101; ++ *((int *)&__m256_op11) = 0x8e8e8e8e; ++ *((int *)&__m256_op10) = 0x8f00ffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7c007c0080008000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7c007c0080008000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xfff10000; ++ *((int *)&__m256_op04) = 0xfff10000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xfff10000; ++ *((int *)&__m256_op00) = 0xfff10000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xfff10000; ++ *((int *)&__m256_op14) = 0xfff10000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xfff10000; ++ *((int *)&__m256_op10) = 0xfff10000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff88ff88; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00040000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00040000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xff00ff00; ++ *((int *)&__m256_op06) = 0x3f003f00; ++ *((int *)&__m256_op05) = 0xff0101fd; ++ *((int *)&__m256_op04) = 0x00010100; ++ *((int *)&__m256_op03) = 0xff00ff00; ++ *((int *)&__m256_op02) = 0x3f003f00; ++ *((int *)&__m256_op01) = 0xff0101fd; ++ *((int *)&__m256_op00) = 0x00010100; ++ *((int *)&__m256_op17) = 0x01ffff43; ++ *((int *)&__m256_op16) = 0x00fffeff; ++ *((int *)&__m256_op15) = 0xfe0000bc; ++ *((int *)&__m256_op14) = 0xff000100; ++ *((int *)&__m256_op13) = 0x01ffff43; ++ *((int *)&__m256_op12) = 0x00fffeff; ++ *((int *)&__m256_op11) = 0xfe0000bc; ++ *((int *)&__m256_op10) = 0xff000100; ++ *((unsigned long *)&__m256i_result3) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fc00fc00; ++ *((unsigned long *)&__m256i_result1) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fc00fc00; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcvt_h_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0cc08723ff900001; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xcc9b89f2f6cef440; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffff00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xfffffff8; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xff800000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xfffffff8; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0xff800000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xff800000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xff800000ff800000; ++ *((unsigned long *)&__m256d_op12) = 0xff800000ff800000; ++ *((unsigned long *)&__m256d_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m256d_op10) = 0xff800000ff800000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xff800000; ++ *((int *)&__m256_result4) = 0xff800000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xff800000; ++ *((int *)&__m256_result0) = 0xff800000; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xf7f8f7f8f800f800; ++ *((unsigned long *)&__m256d_op12) = 0x00003f784000ff80; ++ *((unsigned long *)&__m256d_op11) = 0xf7f8f7f84000fff9; ++ *((unsigned long *)&__m256d_op10) = 0x00003f784000ff80; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xff800000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xff800000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000555500005555; ++ *((unsigned long *)&__m256d_op02) = 0x0000555500005555; ++ *((unsigned long *)&__m256d_op01) = 0x0000555500005555; ++ *((unsigned long *)&__m256d_op00) = 0x0000555500005555; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffb6804cb9; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffb7bbdec0; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffb680489b; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffb7bc02a0; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xfffffffd; ++ *((int *)&__m256_result4) = 0xfffffffd; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xfffffffd; ++ *((int *)&__m256_result0) = 0xfffffffd; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0101010202020203; ++ *((unsigned long *)&__m256d_op12) = 0x0101010201010102; ++ *((unsigned long *)&__m256d_op11) = 0x0101010202020203; ++ *((unsigned long *)&__m256d_op10) = 0x0101010201010102; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256d_op12) = 0x3fff3fff3fff3fc4; ++ *((unsigned long *)&__m256d_op11) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256d_op10) = 0x3fff3fff3fff3fc4; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x3ff9fffa; ++ *((int *)&__m256_result4) = 0x3ff9fffa; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x3ff9fffa; ++ *((int *)&__m256_result0) = 0x3ff9fffa; ++ __m256_out = __lasx_xvfcvt_s_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvth.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvth.c +new file mode 100644 +index 000000000..001ce1c69 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcvth.c +@@ -0,0 +1,485 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x0000aaaa; ++ *((int *)&__m256_op06) = 0x00008bfe; ++ *((int *)&__m256_op05) = 0x0000aaaa; ++ *((int *)&__m256_op04) = 0x0000aaaa; ++ *((int *)&__m256_op03) = 0x0000aaaa; ++ *((int *)&__m256_op02) = 0x00008bfe; ++ *((int *)&__m256_op01) = 0x0000aaaa; ++ *((int *)&__m256_op00) = 0x0000aaaa; ++ *((unsigned long *)&__m256d_result3) = 0x3795554000000000; ++ *((unsigned long *)&__m256d_result2) = 0x37917fc000000000; ++ *((unsigned long *)&__m256d_result1) = 0x3795554000000000; ++ *((unsigned long *)&__m256d_result0) = 0x37917fc000000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0404010008080808; ++ *((unsigned long *)&__m256i_op02) = 0x0408010008080808; ++ *((unsigned long *)&__m256i_op01) = 0x0404010008080808; ++ *((unsigned long *)&__m256i_op00) = 0x0408010008080808; ++ *((int *)&__m256_result7) = 0x38808000; ++ *((int *)&__m256_result6) = 0x37800000; ++ *((int *)&__m256_result5) = 0x39010000; ++ *((int *)&__m256_result4) = 0x39010000; ++ *((int *)&__m256_result3) = 0x38808000; ++ *((int *)&__m256_result2) = 0x37800000; ++ *((int *)&__m256_result1) = 0x39010000; ++ *((int *)&__m256_result0) = 0x39010000; ++ __m256_out = __lasx_xvfcvth_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvth_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvth_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffe0000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x000100010001fffe; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x000100010001fffe; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfcvth_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvth_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00020006; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00020006; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00020006; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00020006; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x37b0003000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x37b0003000000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0xfffffff0; ++ *((int *)&__m256_op06) = 0xfffffff0; ++ *((int *)&__m256_op05) = 0xfffffff0; ++ *((int *)&__m256_op04) = 0xfffffff0; ++ *((int *)&__m256_op03) = 0xfffffff0; ++ *((int *)&__m256_op02) = 0xfffffff0; ++ *((int *)&__m256_op01) = 0xfffffff0; ++ *((int *)&__m256_op00) = 0xfffffff0; ++ *((unsigned long *)&__m256d_result3) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256d_result2) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256d_result1) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256d_result0) = 0xfffffffe00000000; ++ __m256d_out = __lasx_xvfcvth_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffe0000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xf001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0xf000000000000000; ++ *((int *)&__m256_result7) = 0xc6000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xc6000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvtl_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc080ffff0049ffd2; ++ *((unsigned long *)&__m256i_op02) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffeffb9ff9d; ++ *((unsigned long *)&__m256i_op00) = 0x00010000002fff9e; ++ *((int *)&__m256_result7) = 0x34000000; ++ *((int *)&__m256_result6) = 0xfff00000; ++ *((int *)&__m256_result5) = 0xfff6e000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x33800000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x363c0000; ++ *((int *)&__m256_result0) = 0xfff3c000; ++ __m256_out = __lasx_xvfcvtl_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvtl_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x80000000; ++ *((int *)&__m256_op06) = 0x80000000; ++ *((int *)&__m256_op05) = 0x80000000; ++ *((int *)&__m256_op04) = 0xff800000; ++ *((int *)&__m256_op03) = 0x80000000; ++ *((int *)&__m256_op02) = 0x80000000; ++ *((int *)&__m256_op01) = 0x80000000; ++ *((int *)&__m256_op00) = 0xff800000; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op02) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_op01) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op00) = 0xc1d75053f0000000; ++ *((int *)&__m256_result7) = 0xc03ae000; ++ *((int *)&__m256_result6) = 0x420a6000; ++ *((int *)&__m256_result5) = 0xc6000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xc03ae000; ++ *((int *)&__m256_result2) = 0x420a6000; ++ *((int *)&__m256_result1) = 0xc6000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvtl_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x03802fc000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x03802fc000000000; ++ *((int *)&__m256_result7) = 0x38600000; ++ *((int *)&__m256_result6) = 0x3df80000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x38600000; ++ *((int *)&__m256_result2) = 0x3df80000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfcvtl_s_h (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffe0000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfcvtl_d_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-1.c +new file mode 100644 +index 000000000..dd04fd788 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-1.c +@@ -0,0 +1,375 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xbff0000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001700080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001700080; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x4177000800000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x4177000800000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_result3) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xc1f0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xc1f0000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op02) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op01) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op00) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256d_result3) = 0x437fe01fe01fe020; ++ *((unsigned long *)&__m256d_result2) = 0x437fe01fe01fe020; ++ *((unsigned long *)&__m256d_result1) = 0x437fe01fe01fe020; ++ *((unsigned long *)&__m256d_result0) = 0x437fe01fe01fe020; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op02) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_op01) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op00) = 0x132feea900000000; ++ *((unsigned long *)&__m256d_result3) = 0x4393a0a5bc606060; ++ *((unsigned long *)&__m256d_result2) = 0x43b32feea9000000; ++ *((unsigned long *)&__m256d_result1) = 0x4393a0a5bc606060; ++ *((unsigned long *)&__m256d_result0) = 0x43b32feea9000000; ++ __m256d_out = __lasx_xvffint_d_l (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256i_op02) = 0xc5c085372cfabfba; ++ *((unsigned long *)&__m256i_op01) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256i_op00) = 0x0658f2dc0eb21e3c; ++ *((int *)&__m256_result7) = 0x4e5cba76; ++ *((int *)&__m256_result6) = 0xcdbaaa78; ++ *((int *)&__m256_result5) = 0xce68fdeb; ++ *((int *)&__m256_result4) = 0x4e33eaff; ++ *((int *)&__m256_result3) = 0x4e45cc2d; ++ *((int *)&__m256_result2) = 0xcda41b30; ++ *((int *)&__m256_result1) = 0x4ccb1e5c; ++ *((int *)&__m256_result0) = 0x4d6b21e4; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000008000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x4efffe00; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x47000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x4efffe00; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x47000000; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff00; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x477f0000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x477f0000; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010001000030000; ++ *((unsigned long *)&__m256i_op02) = 0x0010001000030000; ++ *((unsigned long *)&__m256i_op01) = 0x0010001000030000; ++ *((unsigned long *)&__m256i_op00) = 0x0010001000030000; ++ *((int *)&__m256_result7) = 0x49800080; ++ *((int *)&__m256_result6) = 0x48400000; ++ *((int *)&__m256_result5) = 0x49800080; ++ *((int *)&__m256_result4) = 0x48400000; ++ *((int *)&__m256_result3) = 0x49800080; ++ *((int *)&__m256_result2) = 0x48400000; ++ *((int *)&__m256_result1) = 0x49800080; ++ *((int *)&__m256_result0) = 0x48400000; ++ __m256_out = __lasx_xvffint_s_w (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_l (__m256i_op0, __m256i_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x4f800000; ++ __m256_out = __lasx_xvffint_s_l (__m256i_op0, __m256i_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffc74180000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff884580000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0xbf800000; ++ *((int *)&__m256_result6) = 0xbf800000; ++ *((int *)&__m256_result5) = 0xd662fa00; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xbf800000; ++ *((int *)&__m256_result2) = 0xbf800000; ++ *((int *)&__m256_result1) = 0xd6ef7500; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_l (__m256i_op0, __m256i_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_l (__m256i_op0, __m256i_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000005000000020; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000005000000020; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00040000; ++ *((int *)&__m256_result7) = 0xdf000000; ++ *((int *)&__m256_result6) = 0x52a00000; ++ *((int *)&__m256_result5) = 0x5b7f00ff; ++ *((int *)&__m256_result4) = 0x5b7f00ff; ++ *((int *)&__m256_result3) = 0xdf000000; ++ *((int *)&__m256_result2) = 0x52a00000; ++ *((int *)&__m256_result1) = 0x5b7f00ff; ++ *((int *)&__m256_result0) = 0x5b7f00ff; ++ __m256_out = __lasx_xvffint_s_l (__m256i_op0, __m256i_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op02) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op01) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op00) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x5d20a0a1; ++ *((int *)&__m256_result6) = 0x5d20a0a1; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x5d20a0a1; ++ *((int *)&__m256_result2) = 0x5d20a0a1; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_l (__m256i_op0, __m256i_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-2.c +new file mode 100644 +index 000000000..3e2b15507 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffint-2.c +@@ -0,0 +1,246 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0101000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x4370100000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x4370100000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020206431; ++ *((unsigned long *)&__m256d_result3) = 0x43c0101010101010; ++ *((unsigned long *)&__m256d_result2) = 0x43c0101010101032; ++ *((unsigned long *)&__m256d_result1) = 0x43c0101010101010; ++ *((unsigned long *)&__m256d_result0) = 0x43c0101010101032; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x40efffe09fa88260; ++ *((unsigned long *)&__m256i_op02) = 0x6b07ca8e013fbf01; ++ *((unsigned long *)&__m256i_op01) = 0x40efffe09fa7e358; ++ *((unsigned long *)&__m256i_op00) = 0x80ce32be3e827f00; ++ *((unsigned long *)&__m256d_result3) = 0x43d03bfff827ea21; ++ *((unsigned long *)&__m256d_result2) = 0x43dac1f2a3804ff0; ++ *((unsigned long *)&__m256d_result1) = 0x43d03bfff827e9f9; ++ *((unsigned long *)&__m256d_result0) = 0x43e019c657c7d050; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0x43f0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x43f0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x43f0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x43f0000000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256d_result3) = 0x41f0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x41f0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x41f0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x41f0000000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op02) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op01) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op00) = 0x0202010202020102; ++ *((unsigned long *)&__m256d_result3) = 0x4380100810101008; ++ *((unsigned long *)&__m256d_result2) = 0x4380100810101008; ++ *((unsigned long *)&__m256d_result1) = 0x4380100810101008; ++ *((unsigned long *)&__m256d_result0) = 0x4380100810101008; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x41f0000000000000; ++ __m256d_out = __lasx_xvffint_d_lu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffbf7f00007fff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffe651ffffbfff; ++ *((int *)&__m256_result7) = 0x4f800000; ++ *((int *)&__m256_result6) = 0x4f800000; ++ *((int *)&__m256_result5) = 0x4f7fffbf; ++ *((int *)&__m256_result4) = 0x46fffe00; ++ *((int *)&__m256_result3) = 0x4f800000; ++ *((int *)&__m256_result2) = 0x4f800000; ++ *((int *)&__m256_result1) = 0x4f7fffe6; ++ *((int *)&__m256_result0) = 0x4f7fffc0; ++ __m256_out = __lasx_xvffint_s_wu (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((int *)&__m256_result7) = 0x4b808080; ++ *((int *)&__m256_result6) = 0x4b808080; ++ *((int *)&__m256_result5) = 0x4f800000; ++ *((int *)&__m256_result4) = 0x4f7fffff; ++ *((int *)&__m256_result3) = 0x4b808080; ++ *((int *)&__m256_result2) = 0x4b808080; ++ *((int *)&__m256_result1) = 0x4f800000; ++ *((int *)&__m256_result0) = 0x4f800000; ++ __m256_out = __lasx_xvffint_s_wu (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_wu (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_wu (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x41000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x41000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x41000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x41000000; ++ __m256_out = __lasx_xvffint_s_wu (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000020; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x42800000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x42000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x42800000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x42000000; ++ __m256_out = __lasx_xvffint_s_wu (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvffint_s_wu (__m256i_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffinth.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffinth.c +new file mode 100644 +index 000000000..e310ff5ee +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvffinth.c +@@ -0,0 +1,262 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0e2d5626ff75cdbc; ++ *((unsigned long *)&__m256i_op02) = 0x5db4b156e2002a78; ++ *((unsigned long *)&__m256i_op01) = 0xeeffbeb03ba3e6b0; ++ *((unsigned long *)&__m256i_op00) = 0x0c16e25eb28d27ea; ++ *((unsigned long *)&__m256d_result3) = 0x41ac5aac4c000000; ++ *((unsigned long *)&__m256d_result2) = 0xc161464880000000; ++ *((unsigned long *)&__m256d_result1) = 0xc1b1004150000000; ++ *((unsigned long *)&__m256d_result0) = 0x41cdd1f358000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000006f0000007f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000006f0000007f; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op02) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op01) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op00) = 0xe161616161614e60; ++ *((unsigned long *)&__m256d_result3) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256d_result2) = 0x41d8585858400000; ++ *((unsigned long *)&__m256d_result1) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256d_result0) = 0x41d8585858400000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256d_result3) = 0x41dfffc000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x41dfffdfffc00000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000007f3a40; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffb79fb74; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffb79fb74; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256d_result3) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xc192181230000000; ++ *((unsigned long *)&__m256d_result1) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xc192181230000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xbff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xbff0000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ffffffff00; ++ *((unsigned long *)&__m256d_result3) = 0x40efffe000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x40efffe000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x41dffc0000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x41dffc0000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op02) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op01) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op00) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256d_result3) = 0xc039000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xc039000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xc039000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xc039000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffinth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5980000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x41d6600000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x41d6600000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256d_result3) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256d_result2) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256d_result1) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256d_result0) = 0xc1d75053f0000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000001f; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x403f000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x403f000000000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00f7000000f70006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00f7000000f70006; ++ *((unsigned long *)&__m256d_result3) = 0x416ee00000000000; ++ *((unsigned long *)&__m256d_result2) = 0x416ee000c0000000; ++ *((unsigned long *)&__m256d_result1) = 0x416ee00000000000; ++ *((unsigned long *)&__m256d_result0) = 0x416ee000c0000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00ff000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ff000000000080; ++ *((unsigned long *)&__m256d_result3) = 0x416fe00000000000; ++ *((unsigned long *)&__m256d_result2) = 0x4060000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x416fe00000000000; ++ *((unsigned long *)&__m256d_result0) = 0x4060000000000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x41cfe01dde000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x41cfe01dde000000; ++ __m256d_out = __lasx_xvffintl_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_d.c +new file mode 100644 +index 000000000..4babf1638 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_d.c +@@ -0,0 +1,429 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++/* { dg-timeout 500 } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrint_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x0); ++ *((unsigned long *)&__m256d_op03) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrint_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000008050501; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000008050501; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrint_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfrint_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrint_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op00) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_result3) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_result2) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_result1) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_result0) = 0xfffffffffffffff8; ++ __m256d_out = __lasx_xvfrint_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000080008001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000080008001; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x7c00000880008000; ++ *((unsigned long *)&__m256d_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x7c00000880008000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7c00000880008000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7c00000880008000; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256d_op02) = 0x6040190d00000000; ++ *((unsigned long *)&__m256d_op01) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256d_op00) = 0x6040190d00000000; ++ *((unsigned long *)&__m256d_result3) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256d_result2) = 0x6040190d00000000; ++ *((unsigned long *)&__m256d_result1) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256d_result0) = 0x6040190d00000000; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256d_op02) = 0x408480007fff0000; ++ *((unsigned long *)&__m256d_op01) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256d_op00) = 0x408480007fff0000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x4084800000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x4084800000000000; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m256d_op02) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m256d_op01) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m256d_op00) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m256d_result3) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m256d_result2) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m256d_result1) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m256d_result0) = 0xffff0001ffff0001; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x3fffbfff80000000; ++ *((unsigned long *)&__m256d_op02) = 0x00004000007f8000; ++ *((unsigned long *)&__m256d_op01) = 0x3fffbfff80000000; ++ *((unsigned long *)&__m256d_op00) = 0x00004000007f8000; ++ *((unsigned long *)&__m256d_result3) = 0x4000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x4000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrne_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x3ff0000000000000; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xfffffefe00000000; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000100da000100fd; ++ *((unsigned long *)&__m256d_op02) = 0x0001ffe20001fefd; ++ *((unsigned long *)&__m256d_op01) = 0x0001009a000100fd; ++ *((unsigned long *)&__m256d_op00) = 0x0001ff640001fefd; ++ *((unsigned long *)&__m256d_result3) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x3ff0000000000000; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256d_op02) = 0x01fc03fc01fc03fc; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256d_op00) = 0x01fc03fc01fc03fc; ++ *((unsigned long *)&__m256d_result3) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256d_result2) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256d_result0) = 0x3ff0000000000000; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0218ff78fc38fc38; ++ *((unsigned long *)&__m256d_op02) = 0xfc00000000000048; ++ *((unsigned long *)&__m256d_op01) = 0x0218ff78fc38fc38; ++ *((unsigned long *)&__m256d_op00) = 0xfc00000000000048; ++ *((unsigned long *)&__m256d_result3) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfc00000000000048; ++ *((unsigned long *)&__m256d_result1) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfc00000000000048; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000000000; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256d_op02) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256d_op01) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256d_op00) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256d_result3) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256d_result2) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256d_result1) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256d_result0) = 0xfffffff0fffffff0; ++ __m256d_out = __lasx_xvfrintrp_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x1e18000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x1e18000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x1e18000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x1e18000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrm_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x017e017e01dd61de; ++ *((unsigned long *)&__m256d_op02) = 0x5d637d043bc4fc43; ++ *((unsigned long *)&__m256d_op01) = 0x01dcc2dce31bc35d; ++ *((unsigned long *)&__m256d_op00) = 0x5e041d245b85fc43; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x5d637d043bc4fc43; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x5e041d245b85fc43; ++ __m256d_out = __lasx_xvfrintrm_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256d_op02) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256d_op01) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256d_op00) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256d_result3) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256d_result2) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256d_result1) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256d_result0) = 0x7c007c007c007c00; ++ __m256d_out = __lasx_xvfrintrm_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfrintrm_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrm_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrm_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x5); ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrm_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfrintrz_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000800000098; ++ *((unsigned long *)&__m256d_op02) = 0x000000040000ffca; ++ *((unsigned long *)&__m256d_op01) = 0x0000000800000098; ++ *((unsigned long *)&__m256d_op00) = 0x000000040000ff79; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrz_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrz_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrintrz_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000781; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrz_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256d_op02) = 0x001fe020001fe020; ++ *((unsigned long *)&__m256d_op01) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256d_op00) = 0x001fe020001fe020; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrz_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfrintrz_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_s.c +new file mode 100644 +index 000000000..9f2fa6747 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrint_s.c +@@ -0,0 +1,723 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++/* { dg-timeout 500 } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffff5f5c; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffff605a; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffff5f5c; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffff605a; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffff5f5c; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffff605a; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffff5f5c; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffff605a; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xc5c5c5c4; ++ *((int *)&__m256_op06) = 0xc5c5c5c4; ++ *((int *)&__m256_op05) = 0x45c5c5c5; ++ *((int *)&__m256_op04) = 0x45c5c5c5; ++ *((int *)&__m256_op03) = 0xc5c5c5c4; ++ *((int *)&__m256_op02) = 0xc5c5c5c4; ++ *((int *)&__m256_op01) = 0x45c5c5c5; ++ *((int *)&__m256_op00) = 0x45c5c5c5; ++ *((int *)&__m256_result7) = 0xc5c5c800; ++ *((int *)&__m256_result6) = 0xc5c5c800; ++ *((int *)&__m256_result5) = 0x45c5c800; ++ *((int *)&__m256_result4) = 0x45c5c800; ++ *((int *)&__m256_result3) = 0xc5c5c800; ++ *((int *)&__m256_result2) = 0xc5c5c800; ++ *((int *)&__m256_result1) = 0x45c5c800; ++ *((int *)&__m256_result0) = 0x45c5c800; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffff6f20; ++ *((int *)&__m256_op05) = 0x0000781e; ++ *((int *)&__m256_op04) = 0x0000f221; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffff6f20; ++ *((int *)&__m256_op01) = 0x0000781e; ++ *((int *)&__m256_op00) = 0x0000f221; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0xffff6f20; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0xffff6f20; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffffb3b4; ++ *((int *)&__m256_op05) = 0xfffffff5; ++ *((int *)&__m256_op04) = 0xffff4738; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffffb3b4; ++ *((int *)&__m256_op01) = 0xfffffff5; ++ *((int *)&__m256_op00) = 0xffff4738; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0xffffb3b4; ++ *((int *)&__m256_result5) = 0xfffffff5; ++ *((int *)&__m256_result4) = 0xffff4738; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0xffffb3b4; ++ *((int *)&__m256_result1) = 0xfffffff5; ++ *((int *)&__m256_result0) = 0xffff4738; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00ff0000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00ff0000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00ff0000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00ff0000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00003fea; ++ *((int *)&__m256_op06) = 0x00013feb; ++ *((int *)&__m256_op05) = 0x00003fe9; ++ *((int *)&__m256_op04) = 0x00014022; ++ *((int *)&__m256_op03) = 0x00003fea; ++ *((int *)&__m256_op02) = 0x00013feb; ++ *((int *)&__m256_op01) = 0x00003fe9; ++ *((int *)&__m256_op00) = 0x00014022; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrint_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x01010101; ++ *((int *)&__m256_op06) = 0x01010101; ++ *((int *)&__m256_op05) = 0x01010101; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x01010101; ++ *((int *)&__m256_op02) = 0x01010101; ++ *((int *)&__m256_op01) = 0x01010101; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x01010101; ++ *((int *)&__m256_op06) = 0x01010101; ++ *((int *)&__m256_op05) = 0x01010101; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x01010101; ++ *((int *)&__m256_op02) = 0x01010101; ++ *((int *)&__m256_op01) = 0x01010101; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrne_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x55555555; ++ *((int *)&__m256_op06) = 0x36aaaaac; ++ *((int *)&__m256_op05) = 0x55555555; ++ *((int *)&__m256_op04) = 0xaaaaaaac; ++ *((int *)&__m256_op03) = 0x55555555; ++ *((int *)&__m256_op02) = 0x36aaaaac; ++ *((int *)&__m256_op01) = 0x55555555; ++ *((int *)&__m256_op00) = 0xaaaaaaac; ++ *((int *)&__m256_result7) = 0x55555555; ++ *((int *)&__m256_result6) = 0x3f800000; ++ *((int *)&__m256_result5) = 0x55555555; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x55555555; ++ *((int *)&__m256_result2) = 0x3f800000; ++ *((int *)&__m256_result1) = 0x55555555; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfrintrp_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrp_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffc741; ++ *((int *)&__m256_op06) = 0x8a023680; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffff8845; ++ *((int *)&__m256_op02) = 0xbb954b00; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffc741; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xffff8845; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrp_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrintrp_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00200101; ++ *((int *)&__m256_op06) = 0x01610000; ++ *((int *)&__m256_op05) = 0x00612000; ++ *((int *)&__m256_op04) = 0x00610000; ++ *((int *)&__m256_op03) = 0x00200101; ++ *((int *)&__m256_op02) = 0x01610000; ++ *((int *)&__m256_op01) = 0x00612000; ++ *((int *)&__m256_op00) = 0x00610000; ++ *((int *)&__m256_result7) = 0x3f800000; ++ *((int *)&__m256_result6) = 0x3f800000; ++ *((int *)&__m256_result5) = 0x3f800000; ++ *((int *)&__m256_result4) = 0x3f800000; ++ *((int *)&__m256_result3) = 0x3f800000; ++ *((int *)&__m256_result2) = 0x3f800000; ++ *((int *)&__m256_result1) = 0x3f800000; ++ *((int *)&__m256_result0) = 0x3f800000; ++ __m256_out = __lasx_xvfrintrp_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xfefefefe; ++ *((int *)&__m256_op04) = 0x01010101; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xfefefefe; ++ *((int *)&__m256_op00) = 0x01010101; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xfefefefe; ++ *((int *)&__m256_result4) = 0x3f800000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xfefefefe; ++ *((int *)&__m256_result0) = 0x3f800000; ++ __m256_out = __lasx_xvfrintrp_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x1c1c1c1c; ++ *((int *)&__m256_op06) = 0x1c1c1c1c; ++ *((int *)&__m256_op05) = 0xfffffffe; ++ *((int *)&__m256_op04) = 0xffffff00; ++ *((int *)&__m256_op03) = 0x1c1c1c1c; ++ *((int *)&__m256_op02) = 0x1c1c1c1c; ++ *((int *)&__m256_op01) = 0xfffffffe; ++ *((int *)&__m256_op00) = 0xffffff00; ++ *((int *)&__m256_result7) = 0x3f800000; ++ *((int *)&__m256_result6) = 0x3f800000; ++ *((int *)&__m256_result5) = 0xfffffffe; ++ *((int *)&__m256_result4) = 0xffffff00; ++ *((int *)&__m256_result3) = 0x3f800000; ++ *((int *)&__m256_result2) = 0x3f800000; ++ *((int *)&__m256_result1) = 0xfffffffe; ++ *((int *)&__m256_result0) = 0xffffff00; ++ __m256_out = __lasx_xvfrintrp_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000008; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00080000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrm_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrm_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrintrm_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x5d20a0a1; ++ *((int *)&__m256_op06) = 0x5d20a0a1; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x5d20a0a1; ++ *((int *)&__m256_op02) = 0x5d20a0a1; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x5d20a0a1; ++ *((int *)&__m256_result6) = 0x5d20a0a1; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x5d20a0a1; ++ *((int *)&__m256_result2) = 0x5d20a0a1; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrm_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x001d001d; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x001d001d; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrm_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000033; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000033; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrm_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrm_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000300; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000303; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrz_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xfffffffe; ++ *((int *)&__m256_op05) = 0xfffffffe; ++ *((int *)&__m256_op04) = 0xfffffefc; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xfffffffe; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xfffffffe; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xfffffffe; ++ *((int *)&__m256_result5) = 0xfffffffe; ++ *((int *)&__m256_result4) = 0xfffffefc; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xfffffffe; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xfffffffe; ++ __m256_out = __lasx_xvfrintrz_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfrintrz_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x0001c4e8; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x0001c4e8; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrintrz_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x80000000; ++ *((int *)&__m256_op06) = 0x80000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x80000000; ++ *((int *)&__m256_op02) = 0x80000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrintrz_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrintrz_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xf5fffc00; ++ *((int *)&__m256_op06) = 0xfc000000; ++ *((int *)&__m256_op05) = 0xf5fffc00; ++ *((int *)&__m256_op04) = 0xfc000000; ++ *((int *)&__m256_op03) = 0xf5fffc00; ++ *((int *)&__m256_op02) = 0xfc000000; ++ *((int *)&__m256_op01) = 0xf5fffc00; ++ *((int *)&__m256_op00) = 0xfc000000; ++ *((int *)&__m256_result7) = 0xf5fffc00; ++ *((int *)&__m256_result6) = 0xfc000000; ++ *((int *)&__m256_result5) = 0xf5fffc00; ++ *((int *)&__m256_result4) = 0xfc000000; ++ *((int *)&__m256_result3) = 0xf5fffc00; ++ *((int *)&__m256_result2) = 0xfc000000; ++ *((int *)&__m256_result1) = 0xf5fffc00; ++ *((int *)&__m256_result0) = 0xfc000000; ++ __m256_out = __lasx_xvfrintrz_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-1.c +new file mode 100644 +index 000000000..c75468d42 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-1.c +@@ -0,0 +1,471 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffcb423a587053; ++ *((unsigned long *)&__m256d_op02) = 0x6d46f43e71141b81; ++ *((unsigned long *)&__m256d_op01) = 0xffffcb423a584528; ++ *((unsigned long *)&__m256d_op00) = 0x9bdf36c8d78158a1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x386000003df80000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x386000003df80000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x555555553f800000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x43f0000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x43f0000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x43f0000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x43f0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffc03b1fc5e050; ++ *((unsigned long *)&__m256d_op02) = 0x6a9e3fa2603a2000; ++ *((unsigned long *)&__m256d_op01) = 0xffffc03b1fc5e050; ++ *((unsigned long *)&__m256d_op00) = 0x6a9e3fa2603a2000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvftintrp_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x7f70000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x7f70000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x7f70000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrp_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256d_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256d_op02) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256d_op01) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256d_op00) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x555555553f800000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrm_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000001c9880; ++ *((unsigned long *)&__m256d_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x00000000001c9880; ++ *((unsigned long *)&__m256d_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x1828f0e09bad7249; ++ *((unsigned long *)&__m256d_op02) = 0x07ffc1b723953cec; ++ *((unsigned long *)&__m256d_op01) = 0x61f2e9b333aab104; ++ *((unsigned long *)&__m256d_op00) = 0x6bf742aa0d7856a0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00ffffff1e9e9e9e; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff9e9eb09e; ++ *((unsigned long *)&__m256d_op01) = 0x00ffffff1e9e9e9e; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff9e9eb09e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_l_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-2.c +new file mode 100644 +index 000000000..ad72f7596 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-2.c +@@ -0,0 +1,1565 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x0000ffff; ++ *((int *)&__m256_op06) = 0xc0008001; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0xc0008001; ++ *((int *)&__m256_op03) = 0x0000ffff; ++ *((int *)&__m256_op02) = 0xc0008001; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0xc0008001; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffffffe; ++ __m256i_out = __lasx_xvftint_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x3f3f3f3c; ++ *((int *)&__m256_op05) = 0xc6c6c6c6; ++ *((int *)&__m256_op04) = 0x8787878a; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x3f3f3f3c; ++ *((int *)&__m256_op01) = 0x8787878a; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0xffff9c9d00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x1f0fdf7f; ++ *((int *)&__m256_op06) = 0x3e3b31d4; ++ *((int *)&__m256_op05) = 0x7ff80000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x1f0fdf7f; ++ *((int *)&__m256_op02) = 0x3e3b31d4; ++ *((int *)&__m256_op01) = 0x7ff80000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000200000003; ++ *((unsigned long *)&__m256d_op12) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256d_op11) = 0x0080000200000003; ++ *((unsigned long *)&__m256d_op10) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x55555555; ++ *((int *)&__m256_op05) = 0x00000001; ++ *((int *)&__m256_op04) = 0x00000004; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x55555555; ++ *((int *)&__m256_op01) = 0x00000001; ++ *((int *)&__m256_op00) = 0x00000004; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x00ff00ffff0000ff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x00ff00ffff0000ff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256d_op02) = 0x7fe363637fe36364; ++ *((unsigned long *)&__m256d_op01) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256d_op00) = 0x7fe363637fe36364; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffffffffff5; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffffffffff5; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffffffffff5; ++ *((unsigned long *)&__m256d_op00) = 0xfffffffffffffff5; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op00) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000007; ++ *((unsigned long *)&__m256d_op02) = 0x000000020000000b; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000007; ++ *((unsigned long *)&__m256d_op00) = 0x000000020000000a; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x000000000000000a; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000000000000a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000505; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x40000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x40000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256d_op12) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256d_op11) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256d_op10) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000004; ++ *((unsigned long *)&__m256d_op02) = 0x0000000004040104; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffd1108199; ++ *((unsigned long *)&__m256d_op00) = 0x00000000714910f9; ++ *((unsigned long *)&__m256d_op13) = 0x000000030000000c; ++ *((unsigned long *)&__m256d_op12) = 0x0000001100000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000500000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000800000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffff7e; ++ *((int *)&__m256_op04) = 0xffffff46; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffff7e; ++ *((int *)&__m256_op00) = 0xffffff46; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256d_op02) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256d_op01) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256d_op00) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256d_op13) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256d_op12) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256d_op11) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256d_op10) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000001000000010; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000001000000010; ++ *((unsigned long *)&__m256d_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256d_op02) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256d_op01) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256d_op00) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x7c00000880008000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000000007c8; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000000007c8; ++ *((unsigned long *)&__m256d_op13) = 0x0000000001fe01fe; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000ff0100; ++ *((unsigned long *)&__m256d_op11) = 0x0000000001fe01fe; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000ff0100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0fffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x0fffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x0fffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x0fffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x000000010000685e; ++ *((unsigned long *)&__m256d_op12) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256d_op11) = 0x000000010000685e; ++ *((unsigned long *)&__m256d_op10) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000800000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfd12fd12; ++ *((int *)&__m256_op06) = 0xfd12fd12; ++ *((int *)&__m256_op05) = 0xfd12fd12; ++ *((int *)&__m256_op04) = 0xfd12fd12; ++ *((int *)&__m256_op03) = 0xfd12fd12; ++ *((int *)&__m256_op02) = 0xfd12fd12; ++ *((int *)&__m256_op01) = 0xfd12fd12; ++ *((int *)&__m256_op00) = 0xfd12fd12; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvftintrne_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256d_op12) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256d_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256d_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrne_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffe4ffe6; ++ *((int *)&__m256_op06) = 0xffe5ffe6; ++ *((int *)&__m256_op05) = 0xffe4ffe6; ++ *((int *)&__m256_op04) = 0xffe5ffe6; ++ *((int *)&__m256_op03) = 0xffe4ffe6; ++ *((int *)&__m256_op02) = 0xffe5ffe6; ++ *((int *)&__m256_op01) = 0xffe4ffe6; ++ *((int *)&__m256_op00) = 0xffe5ffe6; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000001; ++ *((int *)&__m256_op04) = 0x00010102; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x80008000; ++ *((int *)&__m256_op06) = 0x80008000; ++ *((int *)&__m256_op05) = 0x80008000; ++ *((int *)&__m256_op04) = 0x80008000; ++ *((int *)&__m256_op03) = 0x80008000; ++ *((int *)&__m256_op02) = 0x80008000; ++ *((int *)&__m256_op01) = 0x80008000; ++ *((int *)&__m256_op00) = 0x80008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x10000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x10000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00ff00ff; ++ *((int *)&__m256_op06) = 0x00ff00ff; ++ *((int *)&__m256_op05) = 0x00ff00ff; ++ *((int *)&__m256_op04) = 0x00ff00ff; ++ *((int *)&__m256_op03) = 0x00ff00ff; ++ *((int *)&__m256_op02) = 0x00ff00ff; ++ *((int *)&__m256_op01) = 0x00ff00ff; ++ *((int *)&__m256_op00) = 0x00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvftintrp_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0010001000100010; ++ *((unsigned long *)&__m256d_op12) = 0x0010001000107878; ++ *((unsigned long *)&__m256d_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m256d_op10) = 0x0010001000107878; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0040000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0040000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0040000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0040000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0005000500050005; ++ *((unsigned long *)&__m256d_op02) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256d_op01) = 0x0005000500050005; ++ *((unsigned long *)&__m256d_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256d_op13) = 0x00003fea00013fec; ++ *((unsigned long *)&__m256d_op12) = 0x00003fe50001c013; ++ *((unsigned long *)&__m256d_op11) = 0x00003fea00013fec; ++ *((unsigned long *)&__m256d_op10) = 0x00003fe50001c013; ++ *((unsigned long *)&__m256i_result3) = 0x0000000180000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000180000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvftintrp_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffff000000010000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000095120000; ++ *((unsigned long *)&__m256d_op01) = 0xc9da000063f50000; ++ *((unsigned long *)&__m256d_op00) = 0xc7387fff6bbfffff; ++ *((unsigned long *)&__m256d_op13) = 0xfffe000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256d_op11) = 0x4001000100020000; ++ *((unsigned long *)&__m256d_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffefffe; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xfffefffe; ++ *((int *)&__m256_op02) = 0xfffefffd; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0707feb6; ++ *((int *)&__m256_op06) = 0x0707b7d0; ++ *((int *)&__m256_op05) = 0x45baa7ef; ++ *((int *)&__m256_op04) = 0x6a95a985; ++ *((int *)&__m256_op03) = 0x0707feb6; ++ *((int *)&__m256_op02) = 0x0707b7d0; ++ *((int *)&__m256_op01) = 0x45baa7ef; ++ *((int *)&__m256_op00) = 0x6a95a985; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000017547fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000017547fffffff; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x6d6d6d6d; ++ *((int *)&__m256_op06) = 0x6d6d6d6d; ++ *((int *)&__m256_op05) = 0x6d6d6d6d; ++ *((int *)&__m256_op04) = 0x6d6d6d6d; ++ *((int *)&__m256_op03) = 0x6d6d6d6d; ++ *((int *)&__m256_op02) = 0x6d6d6d6d; ++ *((int *)&__m256_op01) = 0x6d6d6d6d; ++ *((int *)&__m256_op00) = 0x6d6d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256d_op02) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256d_op01) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256d_op00) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256d_op13) = 0x00000000c0000005; ++ *((unsigned long *)&__m256d_op12) = 0x21f8c3c4c0000005; ++ *((unsigned long *)&__m256d_op11) = 0x00000000c0000005; ++ *((unsigned long *)&__m256d_op10) = 0x21f8c3c4c0000005; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256d_op12) = 0x8000000100000001; ++ *((unsigned long *)&__m256d_op11) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256d_op10) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xfff10000; ++ *((int *)&__m256_op04) = 0xfff10000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xfff10000; ++ *((int *)&__m256_op00) = 0xfff10000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xfdfcfda8; ++ *((int *)&__m256_op05) = 0x0000e282; ++ *((int *)&__m256_op04) = 0x1d20ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xfdfcfda8; ++ *((int *)&__m256_op01) = 0x0000e282; ++ *((int *)&__m256_op00) = 0x1d20ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0080000000800000; ++ *((unsigned long *)&__m256d_op12) = 0x0080000000800000; ++ *((unsigned long *)&__m256d_op11) = 0x0080000000800000; ++ *((unsigned long *)&__m256d_op10) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256d_op12) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256d_op11) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256d_op10) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256d_op02) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256d_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256d_op00) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256d_op13) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256d_op12) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256d_op11) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256d_op10) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0002fffc; ++ *((unsigned long *)&__m256d_op02) = 0xffff0000fffd0003; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff0002fffc; ++ *((unsigned long *)&__m256d_op00) = 0xffff0000fffd0003; ++ *((unsigned long *)&__m256d_op13) = 0x003f020001400200; ++ *((unsigned long *)&__m256d_op12) = 0x003f00ff003f00c4; ++ *((unsigned long *)&__m256d_op11) = 0x003f020001400200; ++ *((unsigned long *)&__m256d_op10) = 0x003f00ff003f00c4; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrm_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xfffffff0ffff0000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xfffffff0ffff0000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op12) = 0x3ff1808001020101; ++ *((unsigned long *)&__m256d_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op10) = 0x3ff1808001020101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x002e2100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x34000000fff00000; ++ *((unsigned long *)&__m256d_op02) = 0xfff6e00000000000; ++ *((unsigned long *)&__m256d_op01) = 0x3380000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x363c0000fff3c000; ++ *((unsigned long *)&__m256d_op13) = 0x000000030000000c; ++ *((unsigned long *)&__m256d_op12) = 0x0000001100000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000500000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000800000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xa5a5a5a5a5a5a5a5; ++ *((unsigned long *)&__m256d_op12) = 0xa5a5a5a5a5a5a5ff; ++ *((unsigned long *)&__m256d_op11) = 0xa5a5a5a5a5a5a5a5; ++ *((unsigned long *)&__m256d_op10) = 0xa5a5a5a5a5a5a5ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x55555555; ++ *((int *)&__m256_op06) = 0x55555555; ++ *((int *)&__m256_op05) = 0x5d5d5d5d; ++ *((int *)&__m256_op04) = 0x5d555d55; ++ *((int *)&__m256_op03) = 0x55555555; ++ *((int *)&__m256_op02) = 0x55555555; ++ *((int *)&__m256_op01) = 0x5d5ca2a3; ++ *((int *)&__m256_op00) = 0x5d54aaab; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0b085bfc00000000; ++ *((unsigned long *)&__m256d_op12) = 0x0b004bc000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0b085bfc00000000; ++ *((unsigned long *)&__m256d_op10) = 0x0b004bc000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffeeffaf; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000011; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffeeffaf; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000011; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00ff00ff; ++ *((int *)&__m256_op06) = 0x00ff00ff; ++ *((int *)&__m256_op05) = 0x00ff00ff; ++ *((int *)&__m256_op04) = 0x00ff00ff; ++ *((int *)&__m256_op03) = 0x00ff00ff; ++ *((int *)&__m256_op02) = 0x00ff00ff; ++ *((int *)&__m256_op01) = 0x00ff00ff; ++ *((int *)&__m256_op00) = 0x00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x001d001d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256d_op02) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256d_op01) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256d_op00) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00003fe000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x81fa28e4; ++ *((int *)&__m256_op06) = 0x81fa28e4; ++ *((int *)&__m256_op05) = 0x81fa28e4; ++ *((int *)&__m256_op04) = 0x81fa28e4; ++ *((int *)&__m256_op03) = 0x81fa28e4; ++ *((int *)&__m256_op02) = 0x81fa28e4; ++ *((int *)&__m256_op01) = 0x81fa28e4; ++ *((int *)&__m256_op00) = 0x81fa28e4; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_w_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-3.c +new file mode 100644 +index 000000000..19db4e192 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftint-3.c +@@ -0,0 +1,511 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffefffe; ++ *((int *)&__m256_op06) = 0xfffefffe; ++ *((int *)&__m256_op05) = 0xfffefffe; ++ *((int *)&__m256_op04) = 0xfffefffe; ++ *((int *)&__m256_op03) = 0xfffefffe; ++ *((int *)&__m256_op02) = 0xfffefffe; ++ *((int *)&__m256_op01) = 0xfffefffe; ++ *((int *)&__m256_op00) = 0xfffefffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000200; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000200; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000200; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000200; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffffff1; ++ *((int *)&__m256_op06) = 0xfffffff1; ++ *((int *)&__m256_op05) = 0xfffffff1; ++ *((int *)&__m256_op04) = 0xfffffff1; ++ *((int *)&__m256_op03) = 0xfffffff1; ++ *((int *)&__m256_op02) = 0xfffffff1; ++ *((int *)&__m256_op01) = 0xfffffff1; ++ *((int *)&__m256_op00) = 0xfffffff1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x43ef8787; ++ *((int *)&__m256_op04) = 0x8000ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x43ef8787; ++ *((int *)&__m256_op00) = 0x8000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000001df00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000001df00000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0x00030005; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0x00030005; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x7ff80000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x7ff80000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x7ff80000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x7ff80000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000002; ++ *((int *)&__m256_op06) = 0x00000002; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000002; ++ *((int *)&__m256_op02) = 0x00000002; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x7ff00000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x7ff00000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x7ff00000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x7ff00000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00016e00; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00016e00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_wu_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000004000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftint_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x38a966b301f41ffd; ++ *((unsigned long *)&__m256d_op02) = 0x5f6108ee13ff0000; ++ *((unsigned long *)&__m256d_op01) = 0xf41a56e8d10201f6; ++ *((unsigned long *)&__m256d_op00) = 0x683b8b34f1020001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000003868686a20; ++ *((unsigned long *)&__m256d_op02) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256d_op01) = 0x0000003868686a20; ++ *((unsigned long *)&__m256d_op00) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256d_op02) = 0xc2c2c2c2c2c29cc0; ++ *((unsigned long *)&__m256d_op01) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256d_op00) = 0xc2c2c2c2c2c29cc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000007a00f8; ++ *((unsigned long *)&__m256d_op02) = 0x00ff00ff01640092; ++ *((unsigned long *)&__m256d_op01) = 0x00000000007a00f8; ++ *((unsigned long *)&__m256d_op00) = 0x00ff00ff01640092; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000007fff80fe; ++ *((unsigned long *)&__m256d_op02) = 0x000000007fff80fe; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff80007ffe; ++ *((unsigned long *)&__m256d_op00) = 0x0000ff007fff80fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000781; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000408080c111414; ++ *((unsigned long *)&__m256d_op02) = 0x000408080c111414; ++ *((unsigned long *)&__m256d_op01) = 0x000408080c111414; ++ *((unsigned long *)&__m256d_op00) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000008e8c000; ++ *((unsigned long *)&__m256d_op02) = 0x000000000fffc000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000008e8c000; ++ *((unsigned long *)&__m256d_op00) = 0x000000000fffc000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrz_lu_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftintl.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftintl.c +new file mode 100644 +index 000000000..b0fdf7e0b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvftintl.c +@@ -0,0 +1,1580 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0xc58a0a0a; ++ *((int *)&__m256_op06) = 0x07070706; ++ *((int *)&__m256_op05) = 0x006b60e4; ++ *((int *)&__m256_op04) = 0x180b0023; ++ *((int *)&__m256_op03) = 0x1b39153f; ++ *((int *)&__m256_op02) = 0x334b966a; ++ *((int *)&__m256_op01) = 0xf1d75d79; ++ *((int *)&__m256_op00) = 0xefcac002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x40404040; ++ *((int *)&__m256_op06) = 0x40404040; ++ *((int *)&__m256_op05) = 0x40404040; ++ *((int *)&__m256_op04) = 0x40404040; ++ *((int *)&__m256_op03) = 0x40404040; ++ *((int *)&__m256_op02) = 0x40404040; ++ *((int *)&__m256_op01) = 0x40404040; ++ *((int *)&__m256_op00) = 0x40404040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000003; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00080000; ++ *((int *)&__m256_op04) = 0x00000010; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00080000; ++ *((int *)&__m256_op00) = 0x00000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x40f69fe6; ++ *((int *)&__m256_op06) = 0x3c26f4f5; ++ *((int *)&__m256_op05) = 0x7ff7ffff; ++ *((int *)&__m256_op04) = 0x00000007; ++ *((int *)&__m256_op03) = 0x40f69fe6; ++ *((int *)&__m256_op02) = 0x3c26f4f5; ++ *((int *)&__m256_op01) = 0x7ff7ffff; ++ *((int *)&__m256_op00) = 0x00000007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00060000; ++ *((int *)&__m256_op06) = 0x00040000; ++ *((int *)&__m256_op05) = 0x00020000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00060000; ++ *((int *)&__m256_op02) = 0x00040000; ++ *((int *)&__m256_op01) = 0x00020000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffff0000; ++ *((int *)&__m256_op04) = 0xffff0000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffff0000; ++ *((int *)&__m256_op00) = 0xffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x55550000; ++ *((int *)&__m256_op06) = 0x55550000; ++ *((int *)&__m256_op05) = 0x55550000; ++ *((int *)&__m256_op04) = 0x55550000; ++ *((int *)&__m256_op03) = 0x55550000; ++ *((int *)&__m256_op02) = 0x55550000; ++ *((int *)&__m256_op01) = 0x55550000; ++ *((int *)&__m256_op00) = 0x55550000; ++ *((unsigned long *)&__m256i_result3) = 0x00000d5000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000d5000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000d5000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000d5000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x007f8080; ++ *((int *)&__m256_op06) = 0x007f007f; ++ *((int *)&__m256_op05) = 0x007f8080; ++ *((int *)&__m256_op04) = 0x007f007f; ++ *((int *)&__m256_op03) = 0x007f8080; ++ *((int *)&__m256_op02) = 0x007f007f; ++ *((int *)&__m256_op01) = 0x007f8080; ++ *((int *)&__m256_op00) = 0x007f007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x08e8c000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0fffc000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x08e8c000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0fffc000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftinth_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrnel_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000002; ++ *((int *)&__m256_op04) = 0x00000008; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000002; ++ *((int *)&__m256_op00) = 0x00000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrnel_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrnel_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x7f1d7f7f; ++ *((int *)&__m256_op06) = 0x7f1d7f3b; ++ *((int *)&__m256_op05) = 0x02020102; ++ *((int *)&__m256_op04) = 0x02020102; ++ *((int *)&__m256_op03) = 0x7f1d7f7f; ++ *((int *)&__m256_op02) = 0x7f1d7f3b; ++ *((int *)&__m256_op01) = 0x02020102; ++ *((int *)&__m256_op00) = 0x02020102; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrnel_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrnel_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrnel_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrnel_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000102; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x39ffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x39ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x80000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x80000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x80000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x80000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x000055ff; ++ *((int *)&__m256_op06) = 0x01f90ab5; ++ *((int *)&__m256_op05) = 0xaa95eaff; ++ *((int *)&__m256_op04) = 0xfec6e01f; ++ *((int *)&__m256_op03) = 0x000055ff; ++ *((int *)&__m256_op02) = 0x01f90ab5; ++ *((int *)&__m256_op01) = 0xaa95eaff; ++ *((int *)&__m256_op00) = 0xfec6e01f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffeb683; ++ *((int *)&__m256_op06) = 0x9ffffd80; ++ *((int *)&__m256_op05) = 0xfffe97c0; ++ *((int *)&__m256_op04) = 0x20010001; ++ *((int *)&__m256_op03) = 0xfffeb683; ++ *((int *)&__m256_op02) = 0x9ffffd80; ++ *((int *)&__m256_op01) = 0xfffe97c0; ++ *((int *)&__m256_op00) = 0x20010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvftintrpl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x000000ff; ++ *((int *)&__m256_op06) = 0x000000f8; ++ *((int *)&__m256_op05) = 0xbc8ff0ff; ++ *((int *)&__m256_op04) = 0xffffcff8; ++ *((int *)&__m256_op03) = 0x000000ff; ++ *((int *)&__m256_op02) = 0x000000f8; ++ *((int *)&__m256_op01) = 0xbc8ff0ff; ++ *((int *)&__m256_op00) = 0xffffcff8; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000001; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x00000001; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000001; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x00000001; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x7fe37fe3; ++ *((int *)&__m256_op06) = 0x001d001d; ++ *((int *)&__m256_op05) = 0x7fff7fff; ++ *((int *)&__m256_op04) = 0x7fff0000; ++ *((int *)&__m256_op03) = 0x7fe37fe3; ++ *((int *)&__m256_op02) = 0x001d001d; ++ *((int *)&__m256_op01) = 0x7fff7fff; ++ *((int *)&__m256_op00) = 0x7fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000010; ++ *((int *)&__m256_op06) = 0x00000010; ++ *((int *)&__m256_op05) = 0x00000010; ++ *((int *)&__m256_op04) = 0x00000010; ++ *((int *)&__m256_op03) = 0x00000010; ++ *((int *)&__m256_op02) = 0x00000010; ++ *((int *)&__m256_op01) = 0x00000010; ++ *((int *)&__m256_op00) = 0x00000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrml_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x8b141414; ++ *((int *)&__m256_op04) = 0x0e0e0e0e; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x36722a7e; ++ *((int *)&__m256_op00) = 0x66972cd6; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x6a9e3f9a; ++ *((int *)&__m256_op04) = 0x603a2001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x6a9e3f9a; ++ *((int *)&__m256_op00) = 0x603a2001; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000fafe; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000fafe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzl_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00fffefe; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xfffffffc; ++ *((int *)&__m256_op04) = 0x5556aaa8; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xfffffffc; ++ *((int *)&__m256_op00) = 0x5556aaa8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffcc80; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x7dfdff4b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x002a5429; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x002a5429; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x77777777; ++ *((int *)&__m256_op06) = 0xf7777777; ++ *((int *)&__m256_op05) = 0xf7777777; ++ *((int *)&__m256_op04) = 0x77777777; ++ *((int *)&__m256_op03) = 0x77777777; ++ *((int *)&__m256_op02) = 0xf7777777; ++ *((int *)&__m256_op01) = 0xf7777777; ++ *((int *)&__m256_op00) = 0x77777777; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000009; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000009; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000009; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x010c7fbc; ++ *((int *)&__m256_op06) = 0x7e1c7e1c; ++ *((int *)&__m256_op05) = 0xfe000000; ++ *((int *)&__m256_op04) = 0x00000024; ++ *((int *)&__m256_op03) = 0x010c7fbc; ++ *((int *)&__m256_op02) = 0x7e1c7e1c; ++ *((int *)&__m256_op01) = 0xfe000000; ++ *((int *)&__m256_op00) = 0x00000024; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffffe20; ++ *((int *)&__m256_op06) = 0x001dfe1f; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xfffffe20; ++ *((int *)&__m256_op02) = 0x001dfe1f; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffe1; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffe1; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffe1; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffe1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000040; ++ *((int *)&__m256_op06) = 0x00000020; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000040; ++ *((int *)&__m256_op02) = 0x00000020; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrneh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xfefefeff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xff295329; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xfefefeff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xff295329; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xff00ffff; ++ *((int *)&__m256_op06) = 0xff00ffff; ++ *((int *)&__m256_op05) = 0xff00ffff; ++ *((int *)&__m256_op04) = 0xff00ffff; ++ *((int *)&__m256_op03) = 0xff00ffff; ++ *((int *)&__m256_op02) = 0xff00ffff; ++ *((int *)&__m256_op01) = 0xff00ffff; ++ *((int *)&__m256_op00) = 0xff00ffff; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x7fefffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x7fefffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x02020102; ++ *((int *)&__m256_op06) = 0x02020102; ++ *((int *)&__m256_op05) = 0x02020102; ++ *((int *)&__m256_op04) = 0x02020102; ++ *((int *)&__m256_op03) = 0x02020102; ++ *((int *)&__m256_op02) = 0x02020102; ++ *((int *)&__m256_op01) = 0x02020102; ++ *((int *)&__m256_op00) = 0x02020102; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvftintrph_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x515f93f0; ++ *((int *)&__m256_op06) = 0x23600fb9; ++ *((int *)&__m256_op05) = 0x948b39e0; ++ *((int *)&__m256_op04) = 0xb7405f6f; ++ *((int *)&__m256_op03) = 0x48ef0878; ++ *((int *)&__m256_op02) = 0x00007c83; ++ *((int *)&__m256_op01) = 0x78af877c; ++ *((int *)&__m256_op00) = 0x7d7f86f9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000df93f0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000077843; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x17171717; ++ *((int *)&__m256_op06) = 0x17171717; ++ *((int *)&__m256_op05) = 0x000607f7; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x17171717; ++ *((int *)&__m256_op02) = 0x17171717; ++ *((int *)&__m256_op01) = 0x000607f7; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00ff00ff; ++ *((int *)&__m256_op06) = 0x00ff00ff; ++ *((int *)&__m256_op05) = 0x00ff00ff; ++ *((int *)&__m256_op04) = 0x017e01fe; ++ *((int *)&__m256_op03) = 0x017e00ff; ++ *((int *)&__m256_op02) = 0x017e00ff; ++ *((int *)&__m256_op01) = 0x00ff00ff; ++ *((int *)&__m256_op00) = 0x017e01fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfefefefe; ++ *((int *)&__m256_op06) = 0xfefefefe; ++ *((int *)&__m256_op05) = 0xfe8bfe0e; ++ *((int *)&__m256_op04) = 0xfe8bfe12; ++ *((int *)&__m256_op03) = 0xfefefefe; ++ *((int *)&__m256_op02) = 0xfefefefe; ++ *((int *)&__m256_op01) = 0xfe8bfe0e; ++ *((int *)&__m256_op00) = 0xfe8bfe12; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x71717171; ++ *((int *)&__m256_op06) = 0x71010101; ++ *((int *)&__m256_op05) = 0x8e8e8e8e; ++ *((int *)&__m256_op04) = 0x8f00ffff; ++ *((int *)&__m256_op03) = 0x71717171; ++ *((int *)&__m256_op02) = 0x71010101; ++ *((int *)&__m256_op01) = 0x8e8e8e8e; ++ *((int *)&__m256_op00) = 0x8f00ffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00060000; ++ *((int *)&__m256_op06) = 0x00040000; ++ *((int *)&__m256_op05) = 0x00020000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00060000; ++ *((int *)&__m256_op02) = 0x00040000; ++ *((int *)&__m256_op01) = 0x00020000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xff1cff1c; ++ *((int *)&__m256_op06) = 0xff1cff1c; ++ *((int *)&__m256_op05) = 0xff1cff1c; ++ *((int *)&__m256_op04) = 0xff1cff1c; ++ *((int *)&__m256_op03) = 0xff1cff1c; ++ *((int *)&__m256_op02) = 0xff1cff1c; ++ *((int *)&__m256_op01) = 0xff1cff1c; ++ *((int *)&__m256_op00) = 0xff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x000fffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x000fffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrmh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00002262; ++ *((int *)&__m256_op06) = 0x00005111; ++ *((int *)&__m256_op05) = 0x0000165e; ++ *((int *)&__m256_op04) = 0x0000480d; ++ *((int *)&__m256_op03) = 0x00002262; ++ *((int *)&__m256_op02) = 0x00005111; ++ *((int *)&__m256_op01) = 0x0000165e; ++ *((int *)&__m256_op00) = 0x0000480d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00040004; ++ *((int *)&__m256_op06) = 0x00040004; ++ *((int *)&__m256_op05) = 0x00040005; ++ *((int *)&__m256_op04) = 0x00040005; ++ *((int *)&__m256_op03) = 0x00040004; ++ *((int *)&__m256_op02) = 0x00040004; ++ *((int *)&__m256_op01) = 0x00040005; ++ *((int *)&__m256_op00) = 0x00040005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvftintrzh_l_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-floating-point-op.patch
Added
@@ -0,0 +1,5614 @@ +From 9a9935e736a9289e0a1c0a77f4110c206ce36bd2 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:03:17 +0800 +Subject: PATCH 111/124 LoongArch: Add tests for ASX vector floating-point + operation instruction. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvfadd_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfadd_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfclass_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfclass_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvflogb_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvflogb_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfmadd_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfmadd_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfmax_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfmax_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_s.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvfadd_d.c | 545 +++++++++++ + .../loongarch/vector/lasx/lasx-xvfadd_s.c | 911 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvfclass_d.c | 152 +++ + .../loongarch/vector/lasx/lasx-xvfclass_s.c | 95 ++ + .../loongarch/vector/lasx/lasx-xvflogb_d.c | 86 ++ + .../loongarch/vector/lasx/lasx-xvflogb_s.c | 115 +++ + .../loongarch/vector/lasx/lasx-xvfmadd_d.c | 382 ++++++++ + .../loongarch/vector/lasx/lasx-xvfmadd_s.c | 720 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvfmax_d.c | 230 +++++ + .../loongarch/vector/lasx/lasx-xvfmax_s.c | 560 +++++++++++ + .../loongarch/vector/lasx/lasx-xvfmaxa_d.c | 230 +++++ + .../loongarch/vector/lasx/lasx-xvfmaxa_s.c | 506 ++++++++++ + .../loongarch/vector/lasx/lasx-xvfsqrt_d.c | 482 +++++++++ + .../loongarch/vector/lasx/lasx-xvfsqrt_s.c | 457 +++++++++ + 14 files changed, 5471 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_s.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_d.c +new file mode 100644 +index 000000000..657a19e58 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_d.c +@@ -0,0 +1,545 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op02) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffe06df0d7; ++ *((unsigned long *)&__m256d_op11) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffbe8b470f; ++ *((unsigned long *)&__m256d_result3) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256d_result2) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256d_result1) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffbe8b470f; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x41d6600000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x41d6600000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0x41d6600000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0x41d6600000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7fffffffffffffff; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256d_op02) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256d_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256d_op00) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256d_result2) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256d_result1) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256d_result0) = 0x00007fff00007fff; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256d_op02) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256d_op01) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256d_op00) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x000f000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000f000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256d_result2) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256d_result1) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256d_result0) = 0x7fffffffa2beb040; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000001c000000134; ++ *((unsigned long *)&__m256d_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256d_op01) = 0x000001c000000134; ++ *((unsigned long *)&__m256d_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256d_op13) = 0x000001c000000134; ++ *((unsigned long *)&__m256d_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256d_op11) = 0x000001c000000134; ++ *((unsigned long *)&__m256d_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256d_result3) = 0x0000038000000268; ++ *((unsigned long *)&__m256d_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256d_result1) = 0x0000038000000268; ++ *((unsigned long *)&__m256d_result0) = 0x7fff7fff7fff7fff; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000001010100; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000405; ++ *((unsigned long *)&__m256d_op11) = 0x0000000001010100; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000405; ++ *((unsigned long *)&__m256d_result3) = 0x0000000001010100; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000405; ++ *((unsigned long *)&__m256d_result1) = 0x0000000001010100; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000405; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000040; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op13) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256d_op12) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256d_op11) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256d_op10) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256d_result3) = 0x00000000ff890000; ++ *((unsigned long *)&__m256d_result2) = 0x00000000ff790000; ++ *((unsigned long *)&__m256d_result1) = 0x00000000ff890000; ++ *((unsigned long *)&__m256d_result0) = 0x00000000ff790000; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000000000006d; ++ *((unsigned long *)&__m256d_op02) = 0x000000000010006d; ++ *((unsigned long *)&__m256d_op01) = 0x000000000000006d; ++ *((unsigned long *)&__m256d_op00) = 0x000000000010006d; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000080040; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000080040; ++ *((unsigned long *)&__m256d_result3) = 0x00000000000000ad; ++ *((unsigned long *)&__m256d_result2) = 0x00000000001800ad; ++ *((unsigned long *)&__m256d_result1) = 0x00000000000000ad; ++ *((unsigned long *)&__m256d_result0) = 0x00000000001800ad; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256d_op12) = 0x2020000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256d_op10) = 0x2020000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256d_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256d_result0) = 0x7fffffffffffffff; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffff8000; ++ __m256d_out = __lasx_xvfadd_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmul_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000400000001; ++ *((unsigned long *)&__m256d_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000400000001; ++ *((unsigned long *)&__m256d_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmul_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfmul_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000010100000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000010100000000; ++ *((unsigned long *)&__m256d_op13) = 0x00008000003f0000; ++ *((unsigned long *)&__m256d_op12) = 0x00390015003529c1; ++ *((unsigned long *)&__m256d_op11) = 0x00008000003f0000; ++ *((unsigned long *)&__m256d_op10) = 0x00390015003529c1; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmul_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256d_op02) = 0xfe00000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256d_op00) = 0xfe00000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000000000; ++ __m256d_out = __lasx_xvfmul_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x00007ffe81fdfe03; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x80007ffe81fdfe03; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256d_op02) = 0x41d8585858400000; ++ *((unsigned long *)&__m256d_op01) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256d_op00) = 0x41d8585858400000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xff00d5007f00ffff; ++ *((unsigned long *)&__m256d_op12) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256d_op11) = 0xff00d5007f00ffff; ++ *((unsigned long *)&__m256d_op10) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256d_result3) = 0x7f00d5007f00ffff; ++ *((unsigned long *)&__m256d_result2) = 0x7f00ffffff00ffff; ++ *((unsigned long *)&__m256d_result1) = 0x7f00d5007f00ffff; ++ *((unsigned long *)&__m256d_result0) = 0x7f00ffffff00ffff; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff00000002; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000002; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffff00000002; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffff00000002; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op02) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op00) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_result2) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256d_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_result0) = 0x00ff00fe00ff00fe; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsub_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000005536aaaaac; ++ *((unsigned long *)&__m256d_op02) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256d_op01) = 0x0000005536aaaaac; ++ *((unsigned long *)&__m256d_op00) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256d_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op12) = 0x0002555400000000; ++ *((unsigned long *)&__m256d_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op10) = 0x0002555400000000; ++ *((unsigned long *)&__m256d_result3) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfdiv_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffe367cc82f8989a; ++ *((unsigned long *)&__m256d_op02) = 0x4f90000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffc3aaa8d58f43c8; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256d_op12) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256d_op10) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff8000000000000; ++ __m256d_out = __lasx_xvfdiv_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0010000000100000; ++ *((unsigned long *)&__m256d_op02) = 0x0010000000100000; ++ *((unsigned long *)&__m256d_op01) = 0x0010000000100000; ++ *((unsigned long *)&__m256d_op00) = 0x0010000000100000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000483800; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000483800; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x41cc5bb8a95fd1eb; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x41cc5bb8a95fd1eb; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfdiv_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff8000000000000; ++ __m256d_out = __lasx_xvfdiv_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff8000000000000; ++ __m256d_out = __lasx_xvfdiv_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff8000000000000; ++ __m256d_out = __lasx_xvfdiv_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff8000000000000; ++ __m256d_out = __lasx_xvfdiv_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_s.c +new file mode 100644 +index 000000000..4002c4074 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfadd_s.c +@@ -0,0 +1,911 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0x00000001; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000002; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0x00000001; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000002; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0x00000001; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000002; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0x00000001; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000002; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x40b2bf4d; ++ *((int *)&__m256_op06) = 0x30313031; ++ *((int *)&__m256_op05) = 0x50005000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x40b2bf4d; ++ *((int *)&__m256_op02) = 0x30313031; ++ *((int *)&__m256_op01) = 0x50005000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x22be22be; ++ *((int *)&__m256_op15) = 0x7fff7fff; ++ *((int *)&__m256_op14) = 0xa2bea2be; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x22be22be; ++ *((int *)&__m256_op11) = 0x7fff7fff; ++ *((int *)&__m256_op10) = 0xa2bea2be; ++ *((int *)&__m256_result7) = 0x40b2bf4d; ++ *((int *)&__m256_result6) = 0x30313031; ++ *((int *)&__m256_result5) = 0x7fff7fff; ++ *((int *)&__m256_result4) = 0xa2bea2be; ++ *((int *)&__m256_result3) = 0x40b2bf4d; ++ *((int *)&__m256_result2) = 0x30313031; ++ *((int *)&__m256_result1) = 0x7fff7fff; ++ *((int *)&__m256_result0) = 0xa2bea2be; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00ff0000; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00ff0000; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00ff0000; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00ff0000; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000008c; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000008c; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x0000008c; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x0000008c; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000118; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000118; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffff8000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffff8000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffff8000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffff8000; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffff0101; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffff0101; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffff0101; ++ *((int *)&__m256_result4) = 0x00000001; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xffff0101; ++ *((int *)&__m256_result0) = 0x00000001; ++ __m256_out = __lasx_xvfadd_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmul_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmul_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x10101011; ++ *((int *)&__m256_op14) = 0x10101011; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x11111112; ++ *((int *)&__m256_op10) = 0x11111112; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmul_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00060000; ++ *((int *)&__m256_op06) = 0x00040000; ++ *((int *)&__m256_op05) = 0x00020000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00060000; ++ *((int *)&__m256_op02) = 0x00040000; ++ *((int *)&__m256_op01) = 0x00020000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00060000; ++ *((int *)&__m256_op16) = 0x00040000; ++ *((int *)&__m256_op15) = 0x00020000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00060000; ++ *((int *)&__m256_op12) = 0x00040000; ++ *((int *)&__m256_op11) = 0x00020000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmul_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmul_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmul_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x000000ff; ++ *((int *)&__m256_op04) = 0x000000ff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x000000ff; ++ *((int *)&__m256_op00) = 0x000000ff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000101; ++ *((int *)&__m256_op14) = 0x00000101; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000101; ++ *((int *)&__m256_op10) = 0x00000101; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmul_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffff001f; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x007fe268; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffff001f; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x007fe268; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0xffff001f; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x007fe268; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0xffff001f; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x007fe268; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0xffff001f; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0xffff001f; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x7f800000; ++ *((int *)&__m256_op16) = 0x7f800000; ++ *((int *)&__m256_op15) = 0x7f800000; ++ *((int *)&__m256_op14) = 0x7f800000; ++ *((int *)&__m256_op13) = 0x7f800000; ++ *((int *)&__m256_op12) = 0x7f800000; ++ *((int *)&__m256_op11) = 0x7f800000; ++ *((int *)&__m256_op10) = 0x7f800000; ++ *((int *)&__m256_result7) = 0xff800000; ++ *((int *)&__m256_result6) = 0xff800000; ++ *((int *)&__m256_result5) = 0xff800000; ++ *((int *)&__m256_result4) = 0xff800000; ++ *((int *)&__m256_result3) = 0xff800000; ++ *((int *)&__m256_result2) = 0xff800000; ++ *((int *)&__m256_result1) = 0xff800000; ++ *((int *)&__m256_result0) = 0xff800000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x02a54290; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x02a54290; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x02a54290; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x0154dc84; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x02a54290; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000089; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x82a54290; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x028aa700; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x82a54290; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x02a54287; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00004200; ++ *((int *)&__m256_op06) = 0x80000000; ++ *((int *)&__m256_op05) = 0x5fff5fff; ++ *((int *)&__m256_op04) = 0x607f0000; ++ *((int *)&__m256_op03) = 0x00004200; ++ *((int *)&__m256_op02) = 0x80000000; ++ *((int *)&__m256_op01) = 0x5fff5fff; ++ *((int *)&__m256_op00) = 0x607f0000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00004200; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x5fff5fff; ++ *((int *)&__m256_result4) = 0x607f0000; ++ *((int *)&__m256_result3) = 0x00004200; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x5fff5fff; ++ *((int *)&__m256_result0) = 0x607f0000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00800080; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000202; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00800080; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000202; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00800080; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000202; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00800080; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000202; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xfffefffe; ++ *((int *)&__m256_op06) = 0xfffefffe; ++ *((int *)&__m256_op05) = 0xfffefffe; ++ *((int *)&__m256_op04) = 0xfffefffe; ++ *((int *)&__m256_op03) = 0xfffefffe; ++ *((int *)&__m256_op02) = 0xfffefffe; ++ *((int *)&__m256_op01) = 0xfffefffe; ++ *((int *)&__m256_op00) = 0xfffefffe; ++ *((int *)&__m256_op17) = 0x000023a3; ++ *((int *)&__m256_op16) = 0x00003fff; ++ *((int *)&__m256_op15) = 0x000023a3; ++ *((int *)&__m256_op14) = 0x00003fef; ++ *((int *)&__m256_op13) = 0x000023a3; ++ *((int *)&__m256_op12) = 0x00003fff; ++ *((int *)&__m256_op11) = 0x000023a3; ++ *((int *)&__m256_op10) = 0x00003fef; ++ *((int *)&__m256_result7) = 0xfffefffe; ++ *((int *)&__m256_result6) = 0xfffefffe; ++ *((int *)&__m256_result5) = 0xfffefffe; ++ *((int *)&__m256_result4) = 0xfffefffe; ++ *((int *)&__m256_result3) = 0xfffefffe; ++ *((int *)&__m256_result2) = 0xfffefffe; ++ *((int *)&__m256_result1) = 0xfffefffe; ++ *((int *)&__m256_result0) = 0xfffefffe; ++ __m256_out = __lasx_xvfsub_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x002a542a; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x002a542a; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfdiv_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000001; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000001; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7fc00000; ++ *((int *)&__m256_result4) = 0x7fc00000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7fc00000; ++ *((int *)&__m256_result0) = 0x7fc00000; ++ __m256_out = __lasx_xvfdiv_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00fe00fe; ++ *((int *)&__m256_op06) = 0x00fe00fe; ++ *((int *)&__m256_op05) = 0x00fe00fe; ++ *((int *)&__m256_op04) = 0x00fe00fe; ++ *((int *)&__m256_op03) = 0x00fe00fe; ++ *((int *)&__m256_op02) = 0x00fe00fe; ++ *((int *)&__m256_op01) = 0x00fe00fe; ++ *((int *)&__m256_op00) = 0x00fe00fe; ++ *((int *)&__m256_op17) = 0x00fe00fe; ++ *((int *)&__m256_op16) = 0x00fe00fe; ++ *((int *)&__m256_op15) = 0x00fe00fe; ++ *((int *)&__m256_op14) = 0x00fe00fe; ++ *((int *)&__m256_op13) = 0x00fe00fe; ++ *((int *)&__m256_op12) = 0x00fe00fe; ++ *((int *)&__m256_op11) = 0x00fe00fe; ++ *((int *)&__m256_op10) = 0x00fe00fe; ++ *((int *)&__m256_result7) = 0x3f800000; ++ *((int *)&__m256_result6) = 0x3f800000; ++ *((int *)&__m256_result5) = 0x3f800000; ++ *((int *)&__m256_result4) = 0x3f800000; ++ *((int *)&__m256_result3) = 0x3f800000; ++ *((int *)&__m256_result2) = 0x3f800000; ++ *((int *)&__m256_result1) = 0x3f800000; ++ *((int *)&__m256_result0) = 0x3f800000; ++ __m256_out = __lasx_xvfdiv_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7fc00000; ++ *((int *)&__m256_result6) = 0x7fc00000; ++ *((int *)&__m256_result5) = 0x7fc00000; ++ *((int *)&__m256_result4) = 0x7fc00000; ++ *((int *)&__m256_result3) = 0x7fc00000; ++ *((int *)&__m256_result2) = 0x7fc00000; ++ *((int *)&__m256_result1) = 0x7fc00000; ++ *((int *)&__m256_result0) = 0x7fc00000; ++ __m256_out = __lasx_xvfdiv_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x803f6004; ++ *((int *)&__m256_op04) = 0x1f636003; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x803f6004; ++ *((int *)&__m256_op00) = 0x1f636003; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x007f0107; ++ *((int *)&__m256_op14) = 0x00c70106; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x007f0107; ++ *((int *)&__m256_op10) = 0x00c70106; ++ *((int *)&__m256_result7) = 0x7fc00000; ++ *((int *)&__m256_result6) = 0x7fc00000; ++ *((int *)&__m256_result5) = 0xbeff7cfd; ++ *((int *)&__m256_result4) = 0x5e123f94; ++ *((int *)&__m256_result3) = 0x7fc00000; ++ *((int *)&__m256_result2) = 0x7fc00000; ++ *((int *)&__m256_result1) = 0xbeff7cfd; ++ *((int *)&__m256_result0) = 0x5e123f94; ++ __m256_out = __lasx_xvfdiv_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000008; ++ *((int *)&__m256_op06) = 0x60601934; ++ *((int *)&__m256_op05) = 0x00000008; ++ *((int *)&__m256_op04) = 0x00200028; ++ *((int *)&__m256_op03) = 0x00000008; ++ *((int *)&__m256_op02) = 0x60601934; ++ *((int *)&__m256_op01) = 0x00000008; ++ *((int *)&__m256_op00) = 0x00200028; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfdiv_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_d.c +new file mode 100644 +index 000000000..5d5b4c43c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_d.c +@@ -0,0 +1,152 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++/* { dg-timeout 500 } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op02) = 0x0000017f0000017d; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op00) = 0x0000017f0000017f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000200; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op02) = 0x0002000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op00) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256d_op02) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256d_op01) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256d_op00) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256d_op02) = 0xff00000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256d_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000100; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000100; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000000000b7; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256d_op01) = 0x00000000000000b7; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000080; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000400000004000; ++ *((unsigned long *)&__m256d_op02) = 0x0000400000004000; ++ *((unsigned long *)&__m256d_op01) = 0x0000400000004000; ++ *((unsigned long *)&__m256d_op00) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvfclass_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_s.c +new file mode 100644 +index 000000000..888e85b6e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfclass_s.c +@@ -0,0 +1,95 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++/* { dg-timeout 500 } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ ++ *((int *)&__m256_op07) = 0xfffffff8; ++ *((int *)&__m256_op06) = 0xffffff08; ++ *((int *)&__m256_op05) = 0x00ff00f8; ++ *((int *)&__m256_op04) = 0x00ffcff8; ++ *((int *)&__m256_op03) = 0xfffffff8; ++ *((int *)&__m256_op02) = 0xffffff08; ++ *((int *)&__m256_op01) = 0x00ff00f8; ++ *((int *)&__m256_op00) = 0x00ffcff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000008000000080; ++ __m256i_out = __lasx_xvfclass_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvfclass_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000020000000200; ++ __m256i_out = __lasx_xvfclass_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x000000ff; ++ *((int *)&__m256_op04) = 0x000000ff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x000000ff; ++ *((int *)&__m256_op00) = 0x000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000000100; ++ __m256i_out = __lasx_xvfclass_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffffffb; ++ *((int *)&__m256_op06) = 0xfffffffb; ++ *((int *)&__m256_op05) = 0xfffffffb; ++ *((int *)&__m256_op04) = 0xfffffffb; ++ *((int *)&__m256_op03) = 0xfffffffb; ++ *((int *)&__m256_op02) = 0xfffffffb; ++ *((int *)&__m256_op01) = 0xfffffffb; ++ *((int *)&__m256_op00) = 0xfffffffb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvfclass_s (__m256_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_d.c +new file mode 100644 +index 000000000..bba1a06f3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_d.c +@@ -0,0 +1,86 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256d_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xc08f780000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256d_result1) = 0xc08f780000000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvflogb_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvflogb_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvflogb_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvflogb_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvflogb_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvflogb_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_s.c +new file mode 100644 +index 000000000..b641c733f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvflogb_s.c +@@ -0,0 +1,115 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvflogb_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x10101010; ++ *((int *)&__m256_op06) = 0x10101012; ++ *((int *)&__m256_op05) = 0x10101010; ++ *((int *)&__m256_op04) = 0x10101012; ++ *((int *)&__m256_op03) = 0x10101010; ++ *((int *)&__m256_op02) = 0x10101093; ++ *((int *)&__m256_op01) = 0x11111111; ++ *((int *)&__m256_op00) = 0x11111113; ++ *((int *)&__m256_result7) = 0xc2be0000; ++ *((int *)&__m256_result6) = 0xc2be0000; ++ *((int *)&__m256_result5) = 0xc2be0000; ++ *((int *)&__m256_result4) = 0xc2be0000; ++ *((int *)&__m256_result3) = 0xc2be0000; ++ *((int *)&__m256_result2) = 0xc2be0000; ++ *((int *)&__m256_result1) = 0xc2ba0000; ++ *((int *)&__m256_result0) = 0xc2ba0000; ++ __m256_out = __lasx_xvflogb_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0xff800000; ++ *((int *)&__m256_result6) = 0xff800000; ++ *((int *)&__m256_result5) = 0xff800000; ++ *((int *)&__m256_result4) = 0xff800000; ++ *((int *)&__m256_result3) = 0xff800000; ++ *((int *)&__m256_result2) = 0xff800000; ++ *((int *)&__m256_result1) = 0xff800000; ++ *((int *)&__m256_result0) = 0xff800000; ++ __m256_out = __lasx_xvflogb_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0xff800000; ++ *((int *)&__m256_result6) = 0xff800000; ++ *((int *)&__m256_result5) = 0xff800000; ++ *((int *)&__m256_result4) = 0xff800000; ++ *((int *)&__m256_result3) = 0xff800000; ++ *((int *)&__m256_result2) = 0xff800000; ++ *((int *)&__m256_result1) = 0xff800000; ++ *((int *)&__m256_result0) = 0xff800000; ++ __m256_out = __lasx_xvflogb_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000087; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000087; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0xff800000; ++ *((int *)&__m256_result6) = 0xff800000; ++ *((int *)&__m256_result5) = 0xc30e0000; ++ *((int *)&__m256_result4) = 0xff800000; ++ *((int *)&__m256_result3) = 0xff800000; ++ *((int *)&__m256_result2) = 0xff800000; ++ *((int *)&__m256_result1) = 0xc30e0000; ++ *((int *)&__m256_result0) = 0xff800000; ++ __m256_out = __lasx_xvflogb_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_d.c +new file mode 100644 +index 000000000..c85c94bf6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_d.c +@@ -0,0 +1,382 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xe37affb42fc05f69; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x65fb66c81da8e5ba; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256d_op22) = 0x00d6c1c830160048; ++ *((unsigned long *)&__m256d_op21) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256d_op20) = 0xe3aebaf4df958004; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0x00d6c1c830160048; ++ *((unsigned long *)&__m256d_result1) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256d_result0) = 0xe3aebaf4df958004; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256d_op02) = 0x0000468600007f79; ++ *((unsigned long *)&__m256d_op01) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000f3280000dfff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0xfe02fe02fee5fe22; ++ *((unsigned long *)&__m256d_op10) = 0xff49fe4200000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x00020001ffb6ffe0; ++ *((unsigned long *)&__m256d_op20) = 0x0049004200000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256d_result0) = 0xbf28b0686066be60; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0xc5c5c5c5c5c5c5c5; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x2); ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00007f7f00000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00007f7f00007fff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000f1a40; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256d_op12) = 0x0000aaaa0000aaaa; ++ *((unsigned long *)&__m256d_op11) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256d_op10) = 0x0000aaaa0000aaaa; ++ *((unsigned long *)&__m256d_op23) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256d_op22) = 0x0000aaaa0000aaaa; ++ *((unsigned long *)&__m256d_op21) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256d_op20) = 0x0000aaaa0000aaaa; ++ *((unsigned long *)&__m256d_result3) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256d_result2) = 0x0000aaaa0000aaaa; ++ *((unsigned long *)&__m256d_result1) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256d_result0) = 0x0000aaaa0000aaaa; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0202020202020202; ++ *((unsigned long *)&__m256d_op02) = 0x0202810102020202; ++ *((unsigned long *)&__m256d_op01) = 0x0202020202020202; ++ *((unsigned long *)&__m256d_op00) = 0x0202810102020202; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x00007fff00000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x00007fff00000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x00007fff00000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x00007fff00000000; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256d_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x000000000000ffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x000000000000ffff; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256d_op12) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256d_op11) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256d_op10) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256d_op23) = 0x0001000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000100010001; ++ *((unsigned long *)&__m256d_op21) = 0x0001000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000100010001; ++ *((unsigned long *)&__m256d_result3) = 0x0001000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000100010001; ++ *((unsigned long *)&__m256d_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000100010001; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256d_op02) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256d_op01) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256d_op00) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffff000000; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256d_op02) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256d_op01) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256d_op00) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op23) = 0xd3d3d3d3d3d3d3d3; ++ *((unsigned long *)&__m256d_op22) = 0xd3d3d3d3d3d3d3d3; ++ *((unsigned long *)&__m256d_op21) = 0xd3d3d3d3d3d3d3d3; ++ *((unsigned long *)&__m256d_op20) = 0xd3d3d3d3d3d3d3d3; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op02) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op01) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op00) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op13) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op12) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op11) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op10) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256d_op23) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256d_op22) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256d_op21) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256d_op20) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffff5f5c; ++ __m256d_out = __lasx_xvfmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256d_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x00000000fff0e400; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000007380; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000f1c00; ++ *((unsigned long *)&__m256d_op23) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op22) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256d_op21) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op20) = 0x00000000fff0e400; ++ *((unsigned long *)&__m256d_result3) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256d_result2) = 0x80000000ffff8c80; ++ *((unsigned long *)&__m256d_result1) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256d_result0) = 0x80000000fff0e400; ++ __m256d_out = __lasx_xvfmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000007; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00000000000001dc; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000001dc; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x00000000000001dc; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x00000000000001dc; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x80000000000001dc; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x80000000000001dc; ++ __m256d_out = __lasx_xvfmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0404000004040000; ++ *((unsigned long *)&__m256d_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op01) = 0x0404000004040000; ++ *((unsigned long *)&__m256d_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op13) = 0x8011ffee804c004c; ++ *((unsigned long *)&__m256d_op12) = 0x00faff0500c3ff3c; ++ *((unsigned long *)&__m256d_op11) = 0x80f900f980780078; ++ *((unsigned long *)&__m256d_op10) = 0x0057ffa800ceff31; ++ *((unsigned long *)&__m256d_op23) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256d_op22) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256d_op21) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256d_op20) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256d_result3) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256d_result2) = 0x80003fc00000428a; ++ *((unsigned long *)&__m256d_result1) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256d_result0) = 0x80003fc00000428a; ++ __m256d_out = __lasx_xvfmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op23) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op22) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256d_op21) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op20) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256d_result3) = 0x8000000100000001; ++ *((unsigned long *)&__m256d_result2) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256d_result1) = 0x8000000100000001; ++ *((unsigned long *)&__m256d_result0) = 0xffffb2f600006f48; ++ __m256d_out = __lasx_xvfmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_s.c +new file mode 100644 +index 000000000..bde41dd5c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmadd_s.c +@@ -0,0 +1,720 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xf328dfff; ++ *((int *)&__m256_op11) = 0x6651bfff; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x0000ffff; ++ *((int *)&__m256_op26) = 0x0000ff80; ++ *((int *)&__m256_op25) = 0x00004686; ++ *((int *)&__m256_op24) = 0x00007f79; ++ *((int *)&__m256_op23) = 0x0000ffff; ++ *((int *)&__m256_op22) = 0x0000ffff; ++ *((int *)&__m256_op21) = 0x0000f328; ++ *((int *)&__m256_op20) = 0x0000dfff; ++ *((int *)&__m256_result7) = 0x0000ffff; ++ *((int *)&__m256_result6) = 0x0000ff80; ++ *((int *)&__m256_result5) = 0x00004686; ++ *((int *)&__m256_result4) = 0x00007f79; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0x0000ffff; ++ *((int *)&__m256_result1) = 0x0000f328; ++ *((int *)&__m256_result0) = 0x0000dfff; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xfff10000; ++ *((int *)&__m256_op04) = 0xfff10000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xfff10000; ++ *((int *)&__m256_op00) = 0xfff10000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xfff10000; ++ *((int *)&__m256_result4) = 0xfff10000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xfff10000; ++ *((int *)&__m256_result0) = 0xfff10000; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x803f6004; ++ *((int *)&__m256_op24) = 0x1f636003; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x803f6004; ++ *((int *)&__m256_op20) = 0x1f636003; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x803f6004; ++ *((int *)&__m256_result4) = 0x1f636003; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x803f6004; ++ *((int *)&__m256_result0) = 0x1f636003; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffb3430a; ++ *((int *)&__m256_op04) = 0x006ed8b8; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffb3430a; ++ *((int *)&__m256_op00) = 0x006ed8b8; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x000001ff; ++ *((int *)&__m256_op14) = 0x000003fe; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x000001ff; ++ *((int *)&__m256_op10) = 0x000003fe; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x000000ff; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x000000ff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xfff3430a; ++ *((int *)&__m256_result4) = 0x000000ff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xfff3430a; ++ *((int *)&__m256_result0) = 0x000000ff; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xfffeb683; ++ *((int *)&__m256_op06) = 0x9ffffd80; ++ *((int *)&__m256_op05) = 0xfffe97c0; ++ *((int *)&__m256_op04) = 0x20010001; ++ *((int *)&__m256_op03) = 0xfffeb683; ++ *((int *)&__m256_op02) = 0x9ffffd80; ++ *((int *)&__m256_op01) = 0xfffe97c0; ++ *((int *)&__m256_op00) = 0x20010001; ++ *((int *)&__m256_op17) = 0x00009fff; ++ *((int *)&__m256_op16) = 0x9ffffd80; ++ *((int *)&__m256_op15) = 0x0000ffff; ++ *((int *)&__m256_op14) = 0x20010001; ++ *((int *)&__m256_op13) = 0x00009fff; ++ *((int *)&__m256_op12) = 0x9ffffd80; ++ *((int *)&__m256_op11) = 0x0000ffff; ++ *((int *)&__m256_op10) = 0x20010001; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00002080; ++ *((int *)&__m256_op24) = 0xdf5b41cf; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00002080; ++ *((int *)&__m256_op20) = 0xdf5b41cf; ++ *((int *)&__m256_result7) = 0xfffeb683; ++ *((int *)&__m256_result6) = 0x007ffd80; ++ *((int *)&__m256_result5) = 0xfffe97c0; ++ *((int *)&__m256_result4) = 0xdf5b41cf; ++ *((int *)&__m256_result3) = 0xfffeb683; ++ *((int *)&__m256_result2) = 0x007ffd80; ++ *((int *)&__m256_result1) = 0xfffe97c0; ++ *((int *)&__m256_result0) = 0xdf5b41cf; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xfffeb664; ++ *((int *)&__m256_op16) = 0x007ffd61; ++ *((int *)&__m256_op15) = 0xfffe97a1; ++ *((int *)&__m256_op14) = 0xdf5b41b0; ++ *((int *)&__m256_op13) = 0xfffeb664; ++ *((int *)&__m256_op12) = 0x007ffd61; ++ *((int *)&__m256_op11) = 0xfffe97a1; ++ *((int *)&__m256_op10) = 0xdf5b41b0; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x94d7fb52; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xfffeb664; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xfffe97a1; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xfffeb664; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xfffe97a1; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xb70036db; ++ *((int *)&__m256_op16) = 0x12c4007e; ++ *((int *)&__m256_op15) = 0xb7146213; ++ *((int *)&__m256_op14) = 0xfc1e0049; ++ *((int *)&__m256_op13) = 0x000000fe; ++ *((int *)&__m256_op12) = 0xfe02fffe; ++ *((int *)&__m256_op11) = 0xb71c413b; ++ *((int *)&__m256_op10) = 0x199d04b5; ++ *((int *)&__m256_op27) = 0xb70036db; ++ *((int *)&__m256_op26) = 0x12c4007e; ++ *((int *)&__m256_op25) = 0xb7146213; ++ *((int *)&__m256_op24) = 0xfc1e0049; ++ *((int *)&__m256_op23) = 0x000000fe; ++ *((int *)&__m256_op22) = 0xfe02fffe; ++ *((int *)&__m256_op21) = 0xb71c413b; ++ *((int *)&__m256_op20) = 0x199d04b5; ++ *((int *)&__m256_result7) = 0x370036db; ++ *((int *)&__m256_result6) = 0x92c4007e; ++ *((int *)&__m256_result5) = 0x37146213; ++ *((int *)&__m256_result4) = 0x7c1e0049; ++ *((int *)&__m256_result3) = 0x800000fe; ++ *((int *)&__m256_result2) = 0x7e02fffe; ++ *((int *)&__m256_result1) = 0x371c413b; ++ *((int *)&__m256_result0) = 0x999d04b5; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x3f7f7f7e; ++ *((int *)&__m256_op14) = 0xff800000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x3f7f7f7e; ++ *((int *)&__m256_op10) = 0xff800000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x7fffffff; ++ *((int *)&__m256_op24) = 0xff7fffff; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x7fffffff; ++ *((int *)&__m256_op20) = 0xff7fffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x7fffffff; ++ *((int *)&__m256_result4) = 0x7fc00000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x7fffffff; ++ *((int *)&__m256_result0) = 0x7fc00000; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffafaf; ++ *((int *)&__m256_op04) = 0xb3b3dc9d; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffafaf; ++ *((int *)&__m256_op00) = 0xb3b3dc9d; ++ *((int *)&__m256_op17) = 0x00020000; ++ *((int *)&__m256_op16) = 0x00020000; ++ *((int *)&__m256_op15) = 0x00220021; ++ *((int *)&__m256_op14) = 0x004a007e; ++ *((int *)&__m256_op13) = 0x00020000; ++ *((int *)&__m256_op12) = 0x00020000; ++ *((int *)&__m256_op11) = 0x00220021; ++ *((int *)&__m256_op10) = 0x004a007e; ++ *((int *)&__m256_op27) = 0x00000001; ++ *((int *)&__m256_op26) = 0x00007f7f; ++ *((int *)&__m256_op25) = 0x00000001; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000001; ++ *((int *)&__m256_op22) = 0x00007f7f; ++ *((int *)&__m256_op21) = 0x00000001; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000001; ++ *((int *)&__m256_result6) = 0x80007f7f; ++ *((int *)&__m256_result5) = 0xffffafaf; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000001; ++ *((int *)&__m256_result2) = 0x80007f7f; ++ *((int *)&__m256_result1) = 0xffffafaf; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0xffffffe5; ++ *((int *)&__m256_op26) = 0xffffffe5; ++ *((int *)&__m256_op25) = 0xffffffe5; ++ *((int *)&__m256_op24) = 0xffffffe5; ++ *((int *)&__m256_op23) = 0xffffffe5; ++ *((int *)&__m256_op22) = 0xffffffe5; ++ *((int *)&__m256_op21) = 0xffffffe5; ++ *((int *)&__m256_op20) = 0xffffffe5; ++ *((int *)&__m256_result7) = 0xffffffe5; ++ *((int *)&__m256_result6) = 0xffffffe5; ++ *((int *)&__m256_result5) = 0xffffffe5; ++ *((int *)&__m256_result4) = 0xffffffe5; ++ *((int *)&__m256_result3) = 0xffffffe5; ++ *((int *)&__m256_result2) = 0xffffffe5; ++ *((int *)&__m256_result1) = 0xffffffe5; ++ *((int *)&__m256_result0) = 0xffffffe5; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xbfffffff; ++ *((int *)&__m256_op06) = 0xffff8000; ++ *((int *)&__m256_op05) = 0xbfff8000; ++ *((int *)&__m256_op04) = 0x80000000; ++ *((int *)&__m256_op03) = 0xbfffffff; ++ *((int *)&__m256_op02) = 0xffff8000; ++ *((int *)&__m256_op01) = 0xbfff8000; ++ *((int *)&__m256_op00) = 0x80000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0xffff8000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0xffff8000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x02020102; ++ *((int *)&__m256_op16) = 0x02020102; ++ *((int *)&__m256_op15) = 0x02020102; ++ *((int *)&__m256_op14) = 0x02020102; ++ *((int *)&__m256_op13) = 0x02020102; ++ *((int *)&__m256_op12) = 0x02020102; ++ *((int *)&__m256_op11) = 0x02020102; ++ *((int *)&__m256_op10) = 0x02020102; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000008; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000008; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000008; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000008; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000008; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000008; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000008; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000008; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000001; ++ *((int *)&__m256_op24) = 0x00000001; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000001; ++ *((int *)&__m256_op20) = 0x00000001; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x80000001; ++ *((int *)&__m256_result4) = 0x80000001; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x80000001; ++ *((int *)&__m256_result0) = 0x80000001; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000040; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000040; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x40404040; ++ *((int *)&__m256_op26) = 0x40404040; ++ *((int *)&__m256_op25) = 0x40404040; ++ *((int *)&__m256_op24) = 0x40404040; ++ *((int *)&__m256_op23) = 0x40404040; ++ *((int *)&__m256_op22) = 0x40404040; ++ *((int *)&__m256_op21) = 0x40404040; ++ *((int *)&__m256_op20) = 0x40404040; ++ *((int *)&__m256_result7) = 0xc0404040; ++ *((int *)&__m256_result6) = 0xc0404040; ++ *((int *)&__m256_result5) = 0xc0404040; ++ *((int *)&__m256_result4) = 0xc0404040; ++ *((int *)&__m256_result3) = 0xc0404040; ++ *((int *)&__m256_result2) = 0xc0404040; ++ *((int *)&__m256_result1) = 0xc0404040; ++ *((int *)&__m256_result0) = 0xc0404040; ++ __m256_out = __lasx_xvfmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_d.c +new file mode 100644 +index 000000000..207ba167f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_d.c +@@ -0,0 +1,230 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x000000040000fff8; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x000000040000fff8; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x000000040000fff8; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmax_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256d_op02) = 0x0000008000000080; ++ *((unsigned long *)&__m256d_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m256d_op00) = 0x0000008000000080; ++ *((unsigned long *)&__m256d_op13) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256d_op12) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256d_op11) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256d_op10) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256d_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256d_result2) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256d_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256d_result0) = 0x45c5c5c545c5c5c5; ++ __m256d_out = __lasx_xvfmax_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000004290; ++ *((unsigned long *)&__m256d_op02) = 0x00000000002a96ba; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000004290; ++ *((unsigned long *)&__m256d_op00) = 0x00000000002a96ba; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000083f95466; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0101010100005400; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000004290; ++ *((unsigned long *)&__m256d_result2) = 0x0000000083f95466; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000004290; ++ *((unsigned long *)&__m256d_result0) = 0x0101010100005400; ++ __m256d_out = __lasx_xvfmax_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmax_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmax_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0101000101010001; ++ __m256d_out = __lasx_xvfmax_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0001000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000100010001; ++ *((unsigned long *)&__m256d_op11) = 0x0001000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000100010001; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0200000202000002; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0200000202000002; ++ *((unsigned long *)&__m256d_op13) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_op12) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_op11) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_op10) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0101000101010001; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0101000101010001; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256d_op12) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256d_op11) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256d_op10) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmin_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_s.c +new file mode 100644 +index 000000000..9b7703231 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmax_s.c +@@ -0,0 +1,560 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00010101; ++ *((int *)&__m256_op16) = 0x01010101; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00010100; ++ *((int *)&__m256_op11) = 0x00010000; ++ *((int *)&__m256_op10) = 0x01000100; ++ *((int *)&__m256_result7) = 0x00010101; ++ *((int *)&__m256_result6) = 0x01010101; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00010100; ++ *((int *)&__m256_result1) = 0x00010000; ++ *((int *)&__m256_result0) = 0x01000100; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x59800000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x59800000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x59800000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x59800000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00010001; ++ *((int *)&__m256_op16) = 0x00010001; ++ *((int *)&__m256_op15) = 0x00010001; ++ *((int *)&__m256_op14) = 0x00010001; ++ *((int *)&__m256_op13) = 0x00010001; ++ *((int *)&__m256_op12) = 0x00010001; ++ *((int *)&__m256_op11) = 0x00010001; ++ *((int *)&__m256_op10) = 0x00010001; ++ *((int *)&__m256_result7) = 0x00010001; ++ *((int *)&__m256_result6) = 0x00010001; ++ *((int *)&__m256_result5) = 0x00010001; ++ *((int *)&__m256_result4) = 0x00010001; ++ *((int *)&__m256_result3) = 0x00010001; ++ *((int *)&__m256_result2) = 0x00010001; ++ *((int *)&__m256_result1) = 0x00010001; ++ *((int *)&__m256_result0) = 0x00010001; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x7fefffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x7fefffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x000000ff; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x000000ff; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00003fe0; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00003fe0; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00003fe0; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00003fe0; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x0000000e; ++ *((int *)&__m256_op16) = 0x0000000e; ++ *((int *)&__m256_op15) = 0x0000000e; ++ *((int *)&__m256_op14) = 0x0000000e; ++ *((int *)&__m256_op13) = 0x0000000e; ++ *((int *)&__m256_op12) = 0x0000000e; ++ *((int *)&__m256_op11) = 0x0000000e; ++ *((int *)&__m256_op10) = 0x0000000e; ++ *((int *)&__m256_result7) = 0x0000000e; ++ *((int *)&__m256_result6) = 0x0000000e; ++ *((int *)&__m256_result5) = 0x0000000e; ++ *((int *)&__m256_result4) = 0x0000000e; ++ *((int *)&__m256_result3) = 0x0000000e; ++ *((int *)&__m256_result2) = 0x0000000e; ++ *((int *)&__m256_result1) = 0x0000000e; ++ *((int *)&__m256_result0) = 0x0000000e; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffdbbbcf; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffb8579f; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffdbbbcf; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffb8579f; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0xfff8579f; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0xfff8579f; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x40404040; ++ *((int *)&__m256_op16) = 0x40404040; ++ *((int *)&__m256_op15) = 0x40404040; ++ *((int *)&__m256_op14) = 0x40404040; ++ *((int *)&__m256_op13) = 0x40404040; ++ *((int *)&__m256_op12) = 0x40404040; ++ *((int *)&__m256_op11) = 0x40404040; ++ *((int *)&__m256_op10) = 0x40404040; ++ *((int *)&__m256_result7) = 0x40404040; ++ *((int *)&__m256_result6) = 0x40404040; ++ *((int *)&__m256_result5) = 0x40404040; ++ *((int *)&__m256_result4) = 0x40404040; ++ *((int *)&__m256_result3) = 0x40404040; ++ *((int *)&__m256_result2) = 0x40404040; ++ *((int *)&__m256_result1) = 0x40404040; ++ *((int *)&__m256_result0) = 0x40404040; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x0000006d; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0010006d; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x0000006d; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0010006d; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00080040; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00080040; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00080040; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00080040; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00080040; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x0010006d; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00080040; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x0010006d; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x000002ff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x000002ff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x000002ff; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x000002ff; ++ __m256_out = __lasx_xvfmax_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x7ff90000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x1ff60000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xfffffffe; ++ *((int *)&__m256_op14) = 0x00000001; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xfffffffe; ++ *((int *)&__m256_op10) = 0x00000001; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000001; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000001; ++ __m256_out = __lasx_xvfmin_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmin_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmin_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmin_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x0218ff78; ++ *((int *)&__m256_op16) = 0xfc38fc38; ++ *((int *)&__m256_op15) = 0xfc000000; ++ *((int *)&__m256_op14) = 0x00000048; ++ *((int *)&__m256_op13) = 0x0218ff78; ++ *((int *)&__m256_op12) = 0xfc38fc38; ++ *((int *)&__m256_op11) = 0xfc000000; ++ *((int *)&__m256_op10) = 0x00000048; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0xfc38fc38; ++ *((int *)&__m256_result5) = 0xfc000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0xfc38fc38; ++ *((int *)&__m256_result1) = 0xfc000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmin_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x000000f0; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x000000f0; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x000000f0; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x000000f0; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmin_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffe7; ++ *((int *)&__m256_op06) = 0xffffffe7; ++ *((int *)&__m256_op05) = 0xffffffe7; ++ *((int *)&__m256_op04) = 0xffffffe7; ++ *((int *)&__m256_op03) = 0xffffffe7; ++ *((int *)&__m256_op02) = 0xffffffe7; ++ *((int *)&__m256_op01) = 0xffffffe7; ++ *((int *)&__m256_op00) = 0xffffffe7; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmin_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_d.c +new file mode 100644 +index 000000000..96bbb942d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_d.c +@@ -0,0 +1,230 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x000000040000fff8; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x000000040000fff8; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmaxa_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffff8001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmaxa_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000018; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000018; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000018; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000018; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmaxa_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0002000000020000; ++ *((unsigned long *)&__m256d_op02) = 0x0002000000010000; ++ *((unsigned long *)&__m256d_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m256d_op00) = 0x0002000000010000; ++ *((unsigned long *)&__m256d_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0002000000020000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0002000000020000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvfmaxa_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmaxa_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000001; ++ __m256d_out = __lasx_xvfmaxa_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmaxa_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000008000000080; ++ *((unsigned long *)&__m256d_op12) = 0x0000008000000080; ++ *((unsigned long *)&__m256d_op11) = 0x0000008000000080; ++ *((unsigned long *)&__m256d_op10) = 0x0000008000000080; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmina_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256d_op12) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256d_op11) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256d_op10) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmina_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmina_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmina_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op02) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256d_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op00) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00000000000000ff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x00000000000000ff; ++ __m256d_out = __lasx_xvfmina_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_op02) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_op12) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_result2) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7efefefe80ffffff; ++ __m256d_out = __lasx_xvfmina_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0087ff87f807ff87; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0087ff87f807ff87; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfmina_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_s.c +new file mode 100644 +index 000000000..c73a8a74a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfmaxa_s.c +@@ -0,0 +1,506 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00005555; ++ *((int *)&__m256_op16) = 0x00005555; ++ *((int *)&__m256_op15) = 0x000307ff; ++ *((int *)&__m256_op14) = 0xfe72e815; ++ *((int *)&__m256_op13) = 0x00005555; ++ *((int *)&__m256_op12) = 0x00005555; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000015; ++ *((int *)&__m256_result7) = 0x00005555; ++ *((int *)&__m256_result6) = 0x00005555; ++ *((int *)&__m256_result5) = 0x000307ff; ++ *((int *)&__m256_result4) = 0xfe72e815; ++ *((int *)&__m256_result3) = 0x00005555; ++ *((int *)&__m256_result2) = 0x00005555; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000015; ++ __m256_out = __lasx_xvfmaxa_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmaxa_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00ff00ff; ++ *((int *)&__m256_op06) = 0x00ff00ff; ++ *((int *)&__m256_op05) = 0x00ff00ff; ++ *((int *)&__m256_op04) = 0x000c0000; ++ *((int *)&__m256_op03) = 0x00ff00ff; ++ *((int *)&__m256_op02) = 0x00ff00ff; ++ *((int *)&__m256_op01) = 0x00ff00ff; ++ *((int *)&__m256_op00) = 0x00040000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00ff00ff; ++ *((int *)&__m256_result6) = 0x00ff00ff; ++ *((int *)&__m256_result5) = 0x00ff00ff; ++ *((int *)&__m256_result4) = 0x000c0000; ++ *((int *)&__m256_result3) = 0x00ff00ff; ++ *((int *)&__m256_result2) = 0x00ff00ff; ++ *((int *)&__m256_result1) = 0x00ff00ff; ++ *((int *)&__m256_result0) = 0x00040000; ++ __m256_out = __lasx_xvfmaxa_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x000007ff; ++ *((int *)&__m256_op06) = 0x000007ff; ++ *((int *)&__m256_op05) = 0x000007ff; ++ *((int *)&__m256_op04) = 0xfffff800; ++ *((int *)&__m256_op03) = 0x000007ff; ++ *((int *)&__m256_op02) = 0x000007ff; ++ *((int *)&__m256_op01) = 0x000007ff; ++ *((int *)&__m256_op00) = 0xfffff800; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x000007ff; ++ *((int *)&__m256_result6) = 0x000007ff; ++ *((int *)&__m256_result5) = 0x000007ff; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x000007ff; ++ *((int *)&__m256_result2) = 0x000007ff; ++ *((int *)&__m256_result1) = 0x000007ff; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmaxa_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x001f00e0; ++ *((int *)&__m256_op04) = 0x1f1f1fff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x001f00e0; ++ *((int *)&__m256_op00) = 0x1f1f1fff; ++ *((int *)&__m256_op17) = 0x80000000; ++ *((int *)&__m256_op16) = 0x80000000; ++ *((int *)&__m256_op15) = 0x80000000; ++ *((int *)&__m256_op14) = 0xff800000; ++ *((int *)&__m256_op13) = 0x80000000; ++ *((int *)&__m256_op12) = 0x80000000; ++ *((int *)&__m256_op11) = 0x80000000; ++ *((int *)&__m256_op10) = 0xff800000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000001; ++ *((int *)&__m256_result5) = 0x001f00e0; ++ *((int *)&__m256_result4) = 0xff800000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000001; ++ *((int *)&__m256_result1) = 0x001f00e0; ++ *((int *)&__m256_result0) = 0xff800000; ++ __m256_out = __lasx_xvfmaxa_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000001; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000001; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmaxa_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00009fff; ++ *((int *)&__m256_op06) = 0x00002001; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x00009fff; ++ *((int *)&__m256_op02) = 0x00002001; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0xfffeb683; ++ *((int *)&__m256_op16) = 0x9ffffd80; ++ *((int *)&__m256_op15) = 0xfffe97c0; ++ *((int *)&__m256_op14) = 0x20010001; ++ *((int *)&__m256_op13) = 0xfffeb683; ++ *((int *)&__m256_op12) = 0x9ffffd80; ++ *((int *)&__m256_op11) = 0xfffe97c0; ++ *((int *)&__m256_op10) = 0x20010001; ++ *((int *)&__m256_result7) = 0x00009fff; ++ *((int *)&__m256_result6) = 0x9ffffd80; ++ *((int *)&__m256_result5) = 0x0000ffff; ++ *((int *)&__m256_result4) = 0x20010001; ++ *((int *)&__m256_result3) = 0x00009fff; ++ *((int *)&__m256_result2) = 0x9ffffd80; ++ *((int *)&__m256_result1) = 0x0000ffff; ++ *((int *)&__m256_result0) = 0x20010001; ++ __m256_out = __lasx_xvfmaxa_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000170; ++ *((int *)&__m256_op06) = 0x00000080; ++ *((int *)&__m256_op05) = 0xc0650055; ++ *((int *)&__m256_op04) = 0x0055ffab; ++ *((int *)&__m256_op03) = 0x00000170; ++ *((int *)&__m256_op02) = 0x00000080; ++ *((int *)&__m256_op01) = 0xc0650055; ++ *((int *)&__m256_op00) = 0x0055ffab; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffff0000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffff0000; ++ *((int *)&__m256_op17) = 0xfffefffe; ++ *((int *)&__m256_op16) = 0xfffefffe; ++ *((int *)&__m256_op15) = 0xfffefffe; ++ *((int *)&__m256_op14) = 0xfffefffe; ++ *((int *)&__m256_op13) = 0xfffefffe; ++ *((int *)&__m256_op12) = 0xfffefffe; ++ *((int *)&__m256_op11) = 0xfffefffe; ++ *((int *)&__m256_op10) = 0xfffefffe; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0xffff0000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0xffff0000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00fe01f0; ++ *((int *)&__m256_op06) = 0x00010000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00c40086; ++ *((int *)&__m256_op03) = 0x00fe01f0; ++ *((int *)&__m256_op02) = 0x00010000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00c40086; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x82a54290; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x028aa700; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x82a54290; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x02a54287; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00010000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00c40086; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00010000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00c40086; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x02a54290; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0154dc84; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x02a54290; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000089; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x02a54290; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x0154dc84; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x02a54290; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000089; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x02a54290; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x0154dc84; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x02a54290; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000089; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x04000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x04000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00100000; ++ *((int *)&__m256_op06) = 0x00100000; ++ *((int *)&__m256_op05) = 0x00100000; ++ *((int *)&__m256_op04) = 0x00100000; ++ *((int *)&__m256_op03) = 0x00100000; ++ *((int *)&__m256_op02) = 0x00100000; ++ *((int *)&__m256_op01) = 0x00100000; ++ *((int *)&__m256_op00) = 0x00100000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000010; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000010; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000080; ++ *((int *)&__m256_op06) = 0x00000080; ++ *((int *)&__m256_op05) = 0x00000080; ++ *((int *)&__m256_op04) = 0x00000080; ++ *((int *)&__m256_op03) = 0x00000080; ++ *((int *)&__m256_op02) = 0x00000080; ++ *((int *)&__m256_op01) = 0x00000080; ++ *((int *)&__m256_op00) = 0x00000080; ++ *((int *)&__m256_op17) = 0x00000001; ++ *((int *)&__m256_op16) = 0x00000001; ++ *((int *)&__m256_op15) = 0x00000001; ++ *((int *)&__m256_op14) = 0x00000001; ++ *((int *)&__m256_op13) = 0x00000001; ++ *((int *)&__m256_op12) = 0x00000001; ++ *((int *)&__m256_op11) = 0x00000001; ++ *((int *)&__m256_op10) = 0x00000001; ++ *((int *)&__m256_result7) = 0x00000001; ++ *((int *)&__m256_result6) = 0x00000001; ++ *((int *)&__m256_result5) = 0x00000001; ++ *((int *)&__m256_result4) = 0x00000001; ++ *((int *)&__m256_result3) = 0x00000001; ++ *((int *)&__m256_result2) = 0x00000001; ++ *((int *)&__m256_result1) = 0x00000001; ++ *((int *)&__m256_result0) = 0x00000001; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfmina_s (__m256_op0, __m256_op1); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_d.c +new file mode 100644 +index 000000000..18d5c51de +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_d.c +@@ -0,0 +1,482 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256d_op02) = 0x1e18000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256d_op00) = 0x1e18000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x2f03988e2052463e; ++ *((unsigned long *)&__m256d_result2) = 0x2f03988e1409212e; ++ *((unsigned long *)&__m256d_result1) = 0x2f03988e2052463e; ++ *((unsigned long *)&__m256d_result0) = 0x2f03988e1409212e; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256d_op02) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256d_op01) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256d_op00) = 0xff874dc687870000; ++ *((unsigned long *)&__m256d_result3) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256d_result2) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256d_result0) = 0x7ff8000000000000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000100000018; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000100000018; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x1f60000000c00000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x1f60000000c00000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0003030300000300; ++ *((unsigned long *)&__m256d_op02) = 0x0003030300000300; ++ *((unsigned long *)&__m256d_op01) = 0x0003030300000100; ++ *((unsigned long *)&__m256d_op00) = 0x0003030300000100; ++ *((unsigned long *)&__m256d_result3) = 0x1febc46085090ea0; ++ *((unsigned long *)&__m256d_result2) = 0x1febc46085090ea0; ++ *((unsigned long *)&__m256d_result1) = 0x1febc46085090567; ++ *((unsigned long *)&__m256d_result0) = 0x1febc46085090567; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x1f9689fdb16cabbd; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x1f9689fdb16cabbd; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffff0000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000000000000000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000010000000100; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000010000000100; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x1fa0000000080000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffff8000; ++ __m256d_out = __lasx_xvfsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffff00000000; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256d_op02) = 0x0209fefb08140000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256d_result3) = 0x6100000800060005; ++ *((unsigned long *)&__m256d_result2) = 0x5ee1c073b800c916; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x5ff00007fff9fff3; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x555555553f800000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x555555553f800000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x353bb67af686ad9b; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x353bb67af686ad9b; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000001f0000001f; ++ *((unsigned long *)&__m256d_op00) = 0x0000001f0000ffff; ++ *((unsigned long *)&__m256d_result3) = 0x60000007fffe0001; ++ *((unsigned long *)&__m256d_result2) = 0x60000007fffe0001; ++ *((unsigned long *)&__m256d_result1) = 0x6056fd4e7926d5c0; ++ *((unsigned long *)&__m256d_result0) = 0x6056fd4e1a4616c4; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00001bfa000000f9; ++ *((unsigned long *)&__m256d_op02) = 0x000000f900004040; ++ *((unsigned long *)&__m256d_op01) = 0x00001bfa000000f9; ++ *((unsigned long *)&__m256d_op00) = 0x000000f900004040; ++ *((unsigned long *)&__m256d_result3) = 0x60183329ceb52cf0; ++ *((unsigned long *)&__m256d_result2) = 0x6040392cdaf9b3ff; ++ *((unsigned long *)&__m256d_result1) = 0x60183329ceb52cf0; ++ *((unsigned long *)&__m256d_result0) = 0x6040392cdaf9b3ff; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x3de00103153ff5fb; ++ *((unsigned long *)&__m256d_op02) = 0xbffffffe80000000; ++ *((unsigned long *)&__m256d_op01) = 0x3de00103153ff5fb; ++ *((unsigned long *)&__m256d_op00) = 0xbffffffe80000000; ++ *((unsigned long *)&__m256d_result3) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256d_result2) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256d_result0) = 0x7ff8000000000000; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256d_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256d_result3) = 0x606a20bd700e59a3; ++ *((unsigned long *)&__m256d_result2) = 0x6066a09e66c5f1bb; ++ *((unsigned long *)&__m256d_result1) = 0x606a20bd700e59a3; ++ *((unsigned long *)&__m256d_result0) = 0x6066a09e66c5f1bb; ++ __m256d_out = __lasx_xvfrsqrt_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x03fc03fc03f803f8; ++ *((unsigned long *)&__m256d_op02) = 0x03fc03fc03f803f8; ++ *((unsigned long *)&__m256d_op01) = 0x03fc03fc03f803f8; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256d_result2) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256d_result1) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000002a54290; ++ *((unsigned long *)&__m256d_op02) = 0x000000000154dc84; ++ *((unsigned long *)&__m256d_op01) = 0x0000000002a54290; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000089; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op02) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256d_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op00) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xaf0489001bd4c0c3; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xaf0489001bd4c0c3; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000a00000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000fffff614; ++ *((unsigned long *)&__m256d_op01) = 0x0000000a00000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000fffff614; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000001e0000001e; ++ *((unsigned long *)&__m256d_op02) = 0x0000001e0000001e; ++ *((unsigned long *)&__m256d_op01) = 0x0000001e0000001e; ++ *((unsigned long *)&__m256d_op00) = 0x0000001e0000001e; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xff80000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xff80000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8060000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8060000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x7ff0000000000000; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfrecip_d (__m256d_op0); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_s.c +new file mode 100644 +index 000000000..27df4a27d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfsqrt_s.c +@@ -0,0 +1,457 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x00000000; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0x00000000; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0x00000000; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0x00000000; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000ff80; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x60b53246; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x60b5054d; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x0060005a; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x0060005a; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0x5f13ccf5; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0x5f13ccf5; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000002; ++ *((int *)&__m256_op04) = 0x00000008; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000002; ++ *((int *)&__m256_op00) = 0x00000008; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x64800000; ++ *((int *)&__m256_result4) = 0x64000000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x64800000; ++ *((int *)&__m256_result0) = 0x64000000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x000000bd; ++ *((int *)&__m256_op04) = 0xfef907bc; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x000000bd; ++ *((int *)&__m256_op00) = 0xfef907bc; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x62d2acee; ++ *((int *)&__m256_result4) = 0x7fc00000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x62d2acee; ++ *((int *)&__m256_result0) = 0x7fc00000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x04e8296f; ++ *((int *)&__m256_op06) = 0x18181818; ++ *((int *)&__m256_op05) = 0x132feea9; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x04e8296f; ++ *((int *)&__m256_op02) = 0x18181818; ++ *((int *)&__m256_op01) = 0x132feea9; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x5cbe15f2; ++ *((int *)&__m256_result6) = 0x53261036; ++ *((int *)&__m256_result5) = 0x559a674d; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x5cbe15f2; ++ *((int *)&__m256_result2) = 0x53261036; ++ *((int *)&__m256_result1) = 0x559a674d; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrsqrt_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x000000ff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000ff00; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xfc003802; ++ *((int *)&__m256_op06) = 0xfc000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xfc00fc00; ++ *((int *)&__m256_op03) = 0xfc003802; ++ *((int *)&__m256_op02) = 0xfc000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xfc00fc00; ++ *((int *)&__m256_result7) = 0x82ff902d; ++ *((int *)&__m256_result6) = 0x83000000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x82fe0bd9; ++ *((int *)&__m256_result3) = 0x82ff902d; ++ *((int *)&__m256_result2) = 0x83000000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x82fe0bd9; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7f800000; ++ *((int *)&__m256_result4) = 0x7f800000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7f800000; ++ *((int *)&__m256_result0) = 0x7f800000; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xfd02fd02; ++ *((int *)&__m256_op06) = 0xfd02fd02; ++ *((int *)&__m256_op05) = 0xfd02fd02; ++ *((int *)&__m256_op04) = 0xfd02fd02; ++ *((int *)&__m256_op03) = 0xfd02fd02; ++ *((int *)&__m256_op02) = 0xfd02fd02; ++ *((int *)&__m256_op01) = 0xfd02fd02; ++ *((int *)&__m256_op00) = 0xfd02fd02; ++ *((int *)&__m256_result7) = 0x81fa28e4; ++ *((int *)&__m256_result6) = 0x81fa28e4; ++ *((int *)&__m256_result5) = 0x81fa28e4; ++ *((int *)&__m256_result4) = 0x81fa28e4; ++ *((int *)&__m256_result3) = 0x81fa28e4; ++ *((int *)&__m256_result2) = 0x81fa28e4; ++ *((int *)&__m256_result1) = 0x81fa28e4; ++ *((int *)&__m256_result0) = 0x81fa28e4; ++ __m256_out = __lasx_xvfrecip_s (__m256_op0); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-subtraction-instr.patch
Added
@@ -0,0 +1,4566 @@ +From dcd9959504b5e8a0d9346d9ffb45542c1250c538 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:21:25 +0800 +Subject: PATCH 101/124 LoongArch: Add tests for ASX vector subtraction + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvssub-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvssub-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsub.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsubi.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsubwev-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsubwev-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsubwod-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsubwod-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvssub-1.c | 425 +++++++++++ + .../loongarch/vector/lasx/lasx-xvssub-2.c | 695 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsub.c | 590 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsubi.c | 482 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvsubwev-1.c | 530 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvsubwev-2.c | 440 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsubwod-1.c | 695 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsubwod-2.c | 620 ++++++++++++++++ + 8 files changed, 4477 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsub.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-1.c +new file mode 100644 +index 000000000..ada72a16a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-1.c +@@ -0,0 +1,425 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000001dc; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000001dc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff24; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff24; ++ __m256i_out = __lasx_xvssub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvssub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000bdfef907bc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000bdfef907bc; ++ __m256i_out = __lasx_xvssub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffc0; ++ __m256i_out = __lasx_xvssub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x2b2b2b2b1bd68080; ++ *((unsigned long *)&__m256i_op12) = 0x2a2ad4d4f2d8807e; ++ *((unsigned long *)&__m256i_op11) = 0x2b2b2b2b1bd68080; ++ *((unsigned long *)&__m256i_op10) = 0x2a2ad4d4f2d8807e; ++ *((unsigned long *)&__m256i_result3) = 0xd4d5d4d5e42a7f80; ++ *((unsigned long *)&__m256i_result2) = 0xd5d62b2c0d287f82; ++ *((unsigned long *)&__m256i_result1) = 0xd4d5d4d5e42a7f80; ++ *((unsigned long *)&__m256i_result0) = 0xd5d62b2c0d287f82; ++ __m256i_out = __lasx_xvssub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op13) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op11) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff07b4ffff0707; ++ *((unsigned long *)&__m256i_op02) = 0x0000b8070000a787; ++ *((unsigned long *)&__m256i_op01) = 0xffff07b4ffff0707; ++ *((unsigned long *)&__m256i_op00) = 0x0000b8070000a787; ++ *((unsigned long *)&__m256i_op13) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op12) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_op11) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op10) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_result3) = 0xffffb7650000d496; ++ *((unsigned long *)&__m256i_result2) = 0x0001800000018000; ++ *((unsigned long *)&__m256i_result1) = 0xffffb7650000d496; ++ *((unsigned long *)&__m256i_result0) = 0x0001800000018000; ++ __m256i_out = __lasx_xvssub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff000003c0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff000003c0; ++ __m256i_out = __lasx_xvssub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_op02) = 0xff81001dff9d003b; ++ *((unsigned long *)&__m256i_op01) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_op00) = 0xff81001dff9d003b; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_result2) = 0xff81001dff9d003b; ++ *((unsigned long *)&__m256i_result1) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_result0) = 0xff81001dff9d003b; ++ __m256i_out = __lasx_xvssub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op12) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op11) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op10) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00fd0101; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00fd0101; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00fd0101; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00fd0101; ++ __m256i_out = __lasx_xvssub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvssub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256i_op02) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op12) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op11) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op10) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result3) = 0x40f69fe63c26f4f5; ++ *((unsigned long *)&__m256i_result2) = 0x7ff7ffff00000007; ++ *((unsigned long *)&__m256i_result1) = 0x40f69fe63c26f4f5; ++ *((unsigned long *)&__m256i_result0) = 0x7ff7ffff00000007; ++ __m256i_out = __lasx_xvssub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffff00ffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00ffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff00007fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff00007fff; ++ __m256i_out = __lasx_xvssub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001010800; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001010800; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffefef800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffefef800; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007f0000007f0060; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4393a0a5bc606060; ++ *((unsigned long *)&__m256i_op02) = 0x43b32feea9000000; ++ *((unsigned long *)&__m256i_op01) = 0x4393a0a5bc606060; ++ *((unsigned long *)&__m256i_op00) = 0x43b32feea9000000; ++ *((unsigned long *)&__m256i_op13) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256i_op12) = 0x408480007fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256i_op10) = 0x408480007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x04e8296f3c611818; ++ *((unsigned long *)&__m256i_result2) = 0x032eafee29010000; ++ *((unsigned long *)&__m256i_result1) = 0x04e8296f3c611818; ++ *((unsigned long *)&__m256i_result0) = 0x032eafee29010000; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001ff91ff100000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001ff91ff100000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffffff7fff80; ++ *((unsigned long *)&__m256i_result2) = 0x0001ff91ff0ffdfe; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffff7fff80; ++ *((unsigned long *)&__m256i_result0) = 0x0001ff91ff0ffdfe; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvssub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-2.c +new file mode 100644 +index 000000000..f42523850 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssub-2.c +@@ -0,0 +1,695 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xf7fdd5ffebe1c9e3; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xf7fdd5ffebe1c9e3; ++ *((unsigned long *)&__m256i_op13) = 0x000000002467db99; ++ *((unsigned long *)&__m256i_op12) = 0x000000003e143852; ++ *((unsigned long *)&__m256i_op11) = 0x000000002467db99; ++ *((unsigned long *)&__m256i_op10) = 0x000000003e143852; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffdb982466; ++ *((unsigned long *)&__m256i_result2) = 0xf7fdd5ffadcd9191; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffdb982466; ++ *((unsigned long *)&__m256i_result0) = 0xf7fdd5ffadcd9191; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_result3) = 0x7fef0000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fef0000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op12) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op11) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op10) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000f880f87e; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000f880f87e; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff0000; ++ __m256i_out = __lasx_xvssub_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op12) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op10) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op02) = 0x0010511c54440438; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op00) = 0x0010511c54440438; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000030b8; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result2) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result1) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result0) = 0xff1cff1cff1cff1c; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100002000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000808000008080; ++ *((unsigned long *)&__m256i_op02) = 0x0000808000008081; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffec; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffec; ++ *((unsigned long *)&__m256i_result3) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op01) = 0x3fff3fff3fff4000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000403f3fff; ++ *((unsigned long *)&__m256i_op13) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op12) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_op11) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op10) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_result3) = 0x38f7414938f7882f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x38f7414938f78830; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op13) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op12) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op11) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000f0f0f0ef; ++ *((unsigned long *)&__m256i_op02) = 0xf0f0f0f0f0f0f0ef; ++ *((unsigned long *)&__m256i_op01) = 0x00000000f0f0f0ef; ++ *((unsigned long *)&__m256i_op00) = 0xf0f0f0f0f0f0f0ef; ++ *((unsigned long *)&__m256i_op13) = 0x8000000180007f7f; ++ *((unsigned long *)&__m256i_op12) = 0xffffafaf80000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000180007f7f; ++ *((unsigned long *)&__m256i_op10) = 0xffffafaf80000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000070f07170; ++ *((unsigned long *)&__m256i_result2) = 0x0000000070f0f0ef; ++ *((unsigned long *)&__m256i_result1) = 0x0000000070f07170; ++ *((unsigned long *)&__m256i_result0) = 0x0000000070f0f0ef; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000032; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000003c000000032; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000004e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ffffffffffffff; ++ __m256i_out = __lasx_xvssub_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0feff00000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0feff00000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_op12) = 0x2475cef801f0ffdd; ++ *((unsigned long *)&__m256i_op11) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_op10) = 0x419cd5b11c3c5654; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1010100fefefeff0; ++ *((unsigned long *)&__m256i_op12) = 0x0f8f0e8df676f778; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffdfffffffdfffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffdfffffffdfffff; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_op13) = 0xffffffe8ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffe8ffffffe8; ++ *((unsigned long *)&__m256i_op11) = 0xffffffe8ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffe8ffffffe8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000c0000005; ++ *((unsigned long *)&__m256i_op12) = 0x21f8c3c4c0000005; ++ *((unsigned long *)&__m256i_op11) = 0x00000000c0000005; ++ *((unsigned long *)&__m256i_op10) = 0x21f8c3c4c0000005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssub_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsub.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsub.c +new file mode 100644 +index 000000000..c1de1e8d3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsub.c +@@ -0,0 +1,590 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000010100000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000010100000000; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffbe20fc; ++ *((unsigned long *)&__m256i_op02) = 0x000000001cc7ee87; ++ *((unsigned long *)&__m256i_op01) = 0x000000010bb83239; ++ *((unsigned long *)&__m256i_op00) = 0x00000000c409ed87; ++ *((unsigned long *)&__m256i_op13) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op12) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op11) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op10) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result3) = 0x0100020001bf1efd; ++ *((unsigned long *)&__m256i_result2) = 0x010002001ec8ec88; ++ *((unsigned long *)&__m256i_result1) = 0x010002010db9303a; ++ *((unsigned long *)&__m256i_result0) = 0x01000200c60aeb88; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010200000000; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_op02) = 0x7e00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_op00) = 0x7e00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_result2) = 0x7e00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_result0) = 0x7e00000000000000; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_op02) = 0x0000004000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_op00) = 0x0000004000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op12) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_op11) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op10) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff003f003f00; ++ *((unsigned long *)&__m256i_result2) = 0xff0101fd00010100; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff003f003f00; ++ *((unsigned long *)&__m256i_result0) = 0xff0101fd00010100; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff010000fff9; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff19; ++ *((unsigned long *)&__m256i_result1) = 0xff02ff020001fffa; ++ *((unsigned long *)&__m256i_result0) = 0x000100010001fffa; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x43d03bfff827ea21; ++ *((unsigned long *)&__m256i_op12) = 0x43dac1f2a3804ff0; ++ *((unsigned long *)&__m256i_op11) = 0x43d03bfff827e9f9; ++ *((unsigned long *)&__m256i_op10) = 0x43e019c657c7d050; ++ *((unsigned long *)&__m256i_result3) = 0xbc30c40107d915df; ++ *((unsigned long *)&__m256i_result2) = 0xbc263e0e5c80b010; ++ *((unsigned long *)&__m256i_result1) = 0xbc30c40107d91607; ++ *((unsigned long *)&__m256i_result0) = 0xbc20e63aa8392fb0; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_op02) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_op01) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_op00) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result3) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_result2) = 0xff21c241ff21c238; ++ *((unsigned long *)&__m256i_result1) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256i_result0) = 0xff21c241ff21c238; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f8f7f8f7f8f7f8; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xf7f8f7f8f7f8f7f8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000e000e000e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000e000e000e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000e000e000e; ++ *((unsigned long *)&__m256i_op12) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000e000e000e; ++ *((unsigned long *)&__m256i_op10) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x207f207f207f2000; ++ *((unsigned long *)&__m256i_op12) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op11) = 0x00000000207f2000; ++ *((unsigned long *)&__m256i_op10) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result3) = 0xdf80df80df80dfff; ++ *((unsigned long *)&__m256i_result2) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffdf80dfff; ++ *((unsigned long *)&__m256i_result0) = 0x8080808080808080; ++ __m256i_out = __lasx_xvsub_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op02) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op01) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op00) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xc5c5c5c5c5c5c5c5; ++ *((unsigned long *)&__m256i_result2) = 0x45c5c5c645c5c5c6; ++ *((unsigned long *)&__m256i_result1) = 0xc5c5c5c5c5c5c5c5; ++ *((unsigned long *)&__m256i_result0) = 0x45c5c5c645c5c5c6; ++ __m256i_out = __lasx_xvsub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op12) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op10) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xe0f02081c1c4ce2c; ++ *((unsigned long *)&__m256i_result2) = 0x8008000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xe0f02081c1c4ce2c; ++ *((unsigned long *)&__m256i_result0) = 0x8008000000000000; ++ __m256i_out = __lasx_xvsub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000001c9880; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000001c9880; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256i_result2) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256i_result0) = 0x8000000100000001; ++ __m256i_out = __lasx_xvsub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_op02) = 0x00e9a80014ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_op00) = 0x00e9a80014ff0000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00b213181dff0607; ++ *((unsigned long *)&__m256i_result2) = 0x00e9a80114ff0001; ++ *((unsigned long *)&__m256i_result1) = 0x00b213181dff0607; ++ *((unsigned long *)&__m256i_result0) = 0x00e9a80114ff0001; ++ __m256i_out = __lasx_xvsub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000fdfdfe; ++ *((unsigned long *)&__m256i_op13) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op12) = 0x0001fffe00010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7ffe0001fffe0001; ++ *((unsigned long *)&__m256i_result2) = 0x7ffe0001fffeffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000fdfdfe; ++ __m256i_out = __lasx_xvsub_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000006f0000007f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000006f0000007f; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op11) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8080808080808081; ++ *((unsigned long *)&__m256i_result1) = 0x8080808080808081; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_op01) = 0x017e00ff017e00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_op13) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op12) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op11) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op10) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_result3) = 0x1f9d9f9d1f9db29f; ++ *((unsigned long *)&__m256i_result2) = 0x1f9d9f9d201cb39e; ++ *((unsigned long *)&__m256i_result1) = 0x201c9f9d201cb29f; ++ *((unsigned long *)&__m256i_result0) = 0x1f9d9f9d201cb39e; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_op13) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xc192181230000000; ++ *((unsigned long *)&__m256i_op11) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xc192181230000000; ++ *((unsigned long *)&__m256i_result3) = 0x4010000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3e6ce7d9cb7afb62; ++ *((unsigned long *)&__m256i_result1) = 0x4010000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3e6ce7d9cb7afb62; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffed; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x90007fff90008000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0ffffffe90008000; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff80000000; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x05ea05ea05ea05ec; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x05ea05ea05ea05ec; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfa15fa15fa15fa14; ++ __m256i_out = __lasx_xvsub_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsub_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0505070804040404; ++ *((unsigned long *)&__m256i_op02) = 0x0504070804040404; ++ *((unsigned long *)&__m256i_op01) = 0x0505070804040404; ++ *((unsigned long *)&__m256i_op00) = 0x0504070804040404; ++ *((unsigned long *)&__m256i_op13) = 0x0000ff000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ff000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0504080804030405; ++ *((unsigned long *)&__m256i_result2) = 0x0504060904040305; ++ *((unsigned long *)&__m256i_result1) = 0x0504080804030405; ++ *((unsigned long *)&__m256i_result0) = 0x0504060904040305; ++ __m256i_out = __lasx_xvsub_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m256i_op02) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m256i_op00) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_op13) = 0x00000000fff8ff40; ++ *((unsigned long *)&__m256i_op12) = 0x0000ff0100090040; ++ *((unsigned long *)&__m256i_op11) = 0x00000000fff8ff40; ++ *((unsigned long *)&__m256i_op10) = 0x0000ff0100090040; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffefff80; ++ __m256i_out = __lasx_xvsub_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubi.c +new file mode 100644 +index 000000000..a3c0de6d3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubi.c +@@ -0,0 +1,482 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xe9e9e9e9e9e9e9e9; ++ *((unsigned long *)&__m256i_result2) = 0xe9e9e9e9e9e9e9e9; ++ *((unsigned long *)&__m256i_result1) = 0xe9e9e9e9e9e9e9e9; ++ *((unsigned long *)&__m256i_result0) = 0xe9e9e9e9e9e9e9e9; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0xf9f8f9f8f9f9f900; ++ *((unsigned long *)&__m256i_result2) = 0xf9f9f9f9f9f9f9e0; ++ *((unsigned long *)&__m256i_result1) = 0xf9f8f9f8f9f9f900; ++ *((unsigned long *)&__m256i_result0) = 0xf9f9f9f9f9f9f900; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xefefefefefefefef; ++ *((unsigned long *)&__m256i_result2) = 0xefefefefefefefef; ++ *((unsigned long *)&__m256i_result1) = 0xefefefefefefef6e; ++ *((unsigned long *)&__m256i_result0) = 0xeeeeeeeeeeeeeeee; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result2) = 0x6aeaeaeaeaeaeaea; ++ *((unsigned long *)&__m256i_result1) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result0) = 0x6aeaeaeaeaeaeaea; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf6f6f6f6f6f6f6f6; ++ *((unsigned long *)&__m256i_result2) = 0xf6f6f6f6f6f6f6f6; ++ *((unsigned long *)&__m256i_result1) = 0xf6f6f6f6f6f6f6f6; ++ *((unsigned long *)&__m256i_result0) = 0xf6f6f6f6f6f6f6f6; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000002a54290; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result2) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result1) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result0) = 0xe7e7e7e7e7e7e7e7; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op02) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op01) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op00) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_result3) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_result2) = 0xdbcbdbcbdbcbdbcb; ++ *((unsigned long *)&__m256i_result1) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_result0) = 0xdbcbdbcbdbcbdbcb; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0e0d0c0b0e0d0c0b; ++ *((unsigned long *)&__m256i_op02) = 0x0e0d0c0b0e0d0c0b; ++ *((unsigned long *)&__m256i_op01) = 0x0e0d0c0b0e0d0c0b; ++ *((unsigned long *)&__m256i_op00) = 0x0e0d0c0b0e0d0c0b; ++ *((unsigned long *)&__m256i_result3) = 0x0a0908070a090807; ++ *((unsigned long *)&__m256i_result2) = 0x0a0908070a090807; ++ *((unsigned long *)&__m256i_result1) = 0x0a0908070a090807; ++ *((unsigned long *)&__m256i_result0) = 0x0a0908070a090807; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result2) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result1) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result0) = 0xf9f9f9f9f9f9f9f9; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_result2) = 0xf2f2f2f2f2f2f2f2; ++ *((unsigned long *)&__m256i_result1) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_result0) = 0xf2f2f2f2f2f2f2f2; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result2) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result1) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result0) = 0xebebebebebebebeb; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefefdfdfdfd; ++ *((unsigned long *)&__m256i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefefdfdfdfd; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xe4e4e4e4e4e4e4e4; ++ *((unsigned long *)&__m256i_result2) = 0xe4e4e4e4e4e4e4e4; ++ *((unsigned long *)&__m256i_result1) = 0xe4e4e4e4e4e4e4e4; ++ *((unsigned long *)&__m256i_result0) = 0xe4e4e4e4e4e4e4e4; ++ __m256i_out = __lasx_xvsubi_bu (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff7fff7fff7fff7; ++ *((unsigned long *)&__m256i_result2) = 0xfff7fff7fff7fff7; ++ *((unsigned long *)&__m256i_result1) = 0xfff7fff7fff7fff7; ++ *((unsigned long *)&__m256i_result0) = 0xfff7fff7fff7fff7; ++ __m256i_out = __lasx_xvsubi_hu (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000022be22be; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fffa2bea2be; ++ *((unsigned long *)&__m256i_op01) = 0x0000000022be22be; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fffa2bea2be; ++ *((unsigned long *)&__m256i_result3) = 0xffe1ffe1229f229f; ++ *((unsigned long *)&__m256i_result2) = 0x7fe07fe0a29fa29f; ++ *((unsigned long *)&__m256i_result1) = 0xffe1ffe1229f229f; ++ *((unsigned long *)&__m256i_result0) = 0x7fe07fe0a29fa29f; ++ __m256i_out = __lasx_xvsubi_hu (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffe5ffe5ffe5ffe5; ++ *((unsigned long *)&__m256i_result2) = 0xffe5ffe5ffe5ffe5; ++ *((unsigned long *)&__m256i_result1) = 0xffe5ffe5ffe5ffe5; ++ *((unsigned long *)&__m256i_result0) = 0xffe5ffe5ffe5ffe5; ++ __m256i_out = __lasx_xvsubi_hu (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result2) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result1) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result0) = 0xfff1fff1fff1fff1; ++ __m256i_out = __lasx_xvsubi_hu (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_result2) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_result1) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_result0) = 0xfffcfffcfffcfffc; ++ __m256i_out = __lasx_xvsubi_hu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_result2) = 0xffffffef000004ea; ++ *((unsigned long *)&__m256i_result1) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_result0) = 0xffffffefffffffef; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result2) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result1) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result0) = 0xffffffecffffffec; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000018; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000018; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff30000000b; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff30000000b; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff3fffffff3; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff5fffffff5; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff5fffffff5; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff5fffffff5; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff5fffffff5; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256i_result2) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256i_result1) = 0xffffffe5ffffffe5; ++ *((unsigned long *)&__m256i_result0) = 0xffffffe5ffffffe5; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffeaffffffea; ++ *((unsigned long *)&__m256i_result2) = 0xffffffeaffffffea; ++ *((unsigned long *)&__m256i_result1) = 0xffffffeaffffffea; ++ *((unsigned long *)&__m256i_result0) = 0xffffffeaffffffea; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x5d20a0a15d20a0a1; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x5d20a0a15d20a0a1; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x5d20a0895d20a089; ++ *((unsigned long *)&__m256i_result2) = 0xffffffe8ffffffe8; ++ *((unsigned long *)&__m256i_result1) = 0x5d20a0895d20a089; ++ *((unsigned long *)&__m256i_result0) = 0xffffffe8ffffffe8; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffe8ffffffe8; ++ *((unsigned long *)&__m256i_result2) = 0xffffffe8ffffffe8; ++ *((unsigned long *)&__m256i_result1) = 0xffffffe8ffffffe8; ++ *((unsigned long *)&__m256i_result0) = 0xffffffe8ffffffe8; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffcfffffffc; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffcfffffffc; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffcfffffffc; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffcfffffffc; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb683007ffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c0df5b41cf; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb683007ffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c0df5b41cf; ++ *((unsigned long *)&__m256i_result3) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256i_result2) = 0xfffe97a1df5b41b0; ++ *((unsigned long *)&__m256i_result1) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256i_result0) = 0xfffe97a1df5b41b0; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_result2) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_result1) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_result0) = 0xffffffe7ffffffe7; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_op02) = 0x0000400100004001; ++ *((unsigned long *)&__m256i_op01) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_op00) = 0x0000400100004001; ++ *((unsigned long *)&__m256i_result3) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_result2) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_result1) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_result0) = 0x00003ff000003ff0; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256i_result2) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256i_result1) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256i_result0) = 0xffffffe4ffffffe4; ++ __m256i_out = __lasx_xvsubi_wu (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffefe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffefe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffefb; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffefb; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fe; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffc0008001; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffffc0008001; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffc0008001; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffffc0008001; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffffc0007fe9; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffffc0007fe9; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffc0007fe9; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffffc0007fe9; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff6; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffee; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffe6; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffe6; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffe6; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffe6; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffe1; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000006d; ++ *((unsigned long *)&__m256i_result2) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000006d; ++ *((unsigned long *)&__m256i_result0) = 0x000000000010006d; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffee; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff4; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffed; ++ __m256i_out = __lasx_xvsubi_du (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-1.c +new file mode 100644 +index 000000000..caa72ca61 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-1.c +@@ -0,0 +1,530 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op01) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_op01) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_op13) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_op11) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op12) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_op11) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op10) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffb10001ff8f; ++ *((unsigned long *)&__m256i_result2) = 0x0001004c0001ff87; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffb10001ff8f; ++ *((unsigned long *)&__m256i_result0) = 0x0001004c0001ff87; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff7; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ff02ff80fede; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ff02ff80fede; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffc0; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fff0ffc0; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffc0; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fff0ffc0; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff0000; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256i_op12) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256i_op11) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256i_op10) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256i_result3) = 0x0000001d0000001c; ++ *((unsigned long *)&__m256i_result2) = 0x0000001d0000001c; ++ *((unsigned long *)&__m256i_result1) = 0x0000001d0000001c; ++ *((unsigned long *)&__m256i_result0) = 0x0000001d0000001c; ++ __m256i_out = __lasx_xvsubwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffeff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffeff00000000; ++ __m256i_out = __lasx_xvsubwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010203; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefefffffcfa; ++ *((unsigned long *)&__m256i_result1) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffefefffffefe; ++ __m256i_out = __lasx_xvsubwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000600000006; ++ __m256i_out = __lasx_xvsubwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000102; ++ *((unsigned long *)&__m256i_op12) = 0x000000fffffffefe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op12) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op11) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op10) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000008080809; ++ *((unsigned long *)&__m256i_result2) = 0x0000000008080809; ++ *((unsigned long *)&__m256i_result1) = 0x0000000008080809; ++ *((unsigned long *)&__m256i_result0) = 0x0000000008080809; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_op12) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffd; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffffd; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffd; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffffd; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff1cff18; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff1cff18; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000001400; ++ *((unsigned long *)&__m256i_op12) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffec00; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffc3fe007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffc3fe007; ++ __m256i_out = __lasx_xvsubwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00010000; ++ __m256i_out = __lasx_xvsubwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000010100000102; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000010100000102; ++ __m256i_out = __lasx_xvsubwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007fffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x007fffff007fffff; ++ *((unsigned long *)&__m256i_op01) = 0x007fffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x007fffff007fffff; ++ *((unsigned long *)&__m256i_op13) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op12) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_op11) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op10) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffbdff3cffbdff44; ++ __m256i_out = __lasx_xvsubwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-2.c +new file mode 100644 +index 000000000..57d883c04 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwev-2.c +@@ -0,0 +1,440 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op02) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op00) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op12) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op10) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op02) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op01) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op00) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000007f0000007f; ++ *((unsigned long *)&__m256i_result2) = 0x0000007f0000007f; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff80ff01ff80; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff800000007e; ++ __m256i_out = __lasx_xvsubwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op13) = 0x0043030300400300; ++ *((unsigned long *)&__m256i_op12) = 0x0043030300400300; ++ *((unsigned long *)&__m256i_op11) = 0x0043030300400100; ++ *((unsigned long *)&__m256i_op10) = 0x0043030300400100; ++ *((unsigned long *)&__m256i_result3) = 0xffdd001dffe00020; ++ *((unsigned long *)&__m256i_result2) = 0xffdd001dffe00031; ++ *((unsigned long *)&__m256i_result1) = 0xffdd001dffe00020; ++ *((unsigned long *)&__m256i_result0) = 0xffdd001dffe00031; ++ __m256i_out = __lasx_xvsubwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256i_op12) = 0x001fe020001fe020; ++ *((unsigned long *)&__m256i_op11) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256i_op10) = 0x001fe020001fe020; ++ *((unsigned long *)&__m256i_result3) = 0x00ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result2) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result1) = 0x00ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result0) = 0xffe1ffe0ffe1ffe0; ++ __m256i_out = __lasx_xvsubwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffee00ba; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffee00ba; ++ *((unsigned long *)&__m256i_op13) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op12) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00fffff500ba; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00fffff500ba; ++ __m256i_out = __lasx_xvsubwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000004efffe00; ++ *((unsigned long *)&__m256i_op02) = 0x0000000047000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000004efffe00; ++ *((unsigned long *)&__m256i_op00) = 0x0000000047000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff01; ++ __m256i_out = __lasx_xvsubwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff01ff01ff01; ++ __m256i_out = __lasx_xvsubwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000fffc0000fffc; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffc0000fffc; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001504f4c4b2361; ++ *((unsigned long *)&__m256i_op02) = 0x303338a48f374969; ++ *((unsigned long *)&__m256i_op01) = 0x0001504f4c4b2361; ++ *((unsigned long *)&__m256i_op00) = 0x303338a48f374969; ++ *((unsigned long *)&__m256i_op13) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op12) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op10) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_result2) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_result1) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_result0) = 0xffff47b4ffff5879; ++ __m256i_out = __lasx_xvsubwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvsubwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffbf4; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000308; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000010100000102; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000010100000102; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffefd; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffffefd; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffe40; ++ *((unsigned long *)&__m256i_op13) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x80000000ffff8c80; ++ *((unsigned long *)&__m256i_op11) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x80000000fff0e400; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000f1a40; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000003effe1; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000003effe1; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000003effe1; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000003effe1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op13) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffff7; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffffff7; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff0002; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff0002; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff0002; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff0002; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff0000; ++ __m256i_out = __lasx_xvsubwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x5d20a0a15d20a0a1; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x5d20a0a15d20a0a1; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000000001; ++ __m256i_out = __lasx_xvsubwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffeffffff00; ++ *((unsigned long *)&__m256i_op11) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffeffffff00; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000100; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000100; ++ __m256i_out = __lasx_xvsubwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op01) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsubwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-1.c +new file mode 100644 +index 000000000..1687729d3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-1.c +@@ -0,0 +1,695 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op13) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op12) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op11) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op10) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result3) = 0xffe4ffe6ffe5ffe6; ++ *((unsigned long *)&__m256i_result2) = 0xffe4ffe6ffe5ffe6; ++ *((unsigned long *)&__m256i_result1) = 0xffe4ffe6ffe5ffe6; ++ *((unsigned long *)&__m256i_result0) = 0xffe4ffe6ffe5ffe6; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x017e01fe01fe01fe; ++ *((unsigned long *)&__m256i_op12) = 0x0586060601fe0202; ++ *((unsigned long *)&__m256i_op11) = 0x017e01fe01fe0000; ++ *((unsigned long *)&__m256i_op10) = 0x0586060601fe0004; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffbfffafffffffe; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result0) = 0xfffbfffaffff0000; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op02) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op01) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op00) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_result1) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffefffefffefffef; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_op13) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100008000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100007fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100008000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100007fff; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256i_result2) = 0x000043efffff8000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256i_result0) = 0x000043efffff8000; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000003f00001f63; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000003f00001f63; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff80ff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff80ff; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op13) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op12) = 0xc3030000ff800000; ++ *((unsigned long *)&__m256i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op10) = 0xc3030000ff800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result2) = 0x00003cfc0000006f; ++ *((unsigned long *)&__m256i_result1) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result0) = 0x00003cfc0000006f; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op12) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op10) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0xffffb2f600006f48; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000001fffe; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000060000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000060000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000020202020; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fff8ff40; ++ *((unsigned long *)&__m256i_op02) = 0x0000ff0100090040; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fff8ff40; ++ *((unsigned long *)&__m256i_op00) = 0x0000ff0100090040; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff02; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff02; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000700000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000700000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000700000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000700000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffe00; ++ __m256i_out = __lasx_xvsubwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x1e17ffffd0fc6772; ++ *((unsigned long *)&__m256i_op12) = 0x1e17ffffebf6ded2; ++ *((unsigned long *)&__m256i_op11) = 0x1e17ffffd0fc6772; ++ *((unsigned long *)&__m256i_op10) = 0x1e17ffffebf6ded2; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xe1e800002f03988d; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xe1e800002f03988d; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x9cffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x9cffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x6300000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x6300000000000001; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op12) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000808; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xf7f7f7f7f7f7f7f8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op12) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op11) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op10) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000e000e000e000e; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op02) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op00) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0a0a000000000a0a; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-2.c +new file mode 100644 +index 000000000..8d6ed92a1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsubwod-2.c +@@ -0,0 +1,620 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op12) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op11) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op10) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff01ff01ff01; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000020001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffcc8000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007dfdff4b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff3400000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff83ff01; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ff010000ff01; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff010000ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000ff010000ff01; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff010000ff01; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op02) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op01) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op00) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0xfff0fff0fff0fff0; ++ *((unsigned long *)&__m256i_result1) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_result0) = 0xfff0fff0fff0fff0; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op12) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op11) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op10) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_op12) = 0xdfc2df80df80df87; ++ *((unsigned long *)&__m256i_op11) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_op10) = 0xdfc2df80df80df87; ++ *((unsigned long *)&__m256i_result3) = 0xff21ff21ff21ff21; ++ *((unsigned long *)&__m256i_result2) = 0xff21ff21ff21ff21; ++ *((unsigned long *)&__m256i_result1) = 0xff21ff21ff21ff21; ++ *((unsigned long *)&__m256i_result0) = 0xff21ff21ff21ff21; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x4079808280057efe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007ffcfcfd020202; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x004000800080007e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000fc00fd0002; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff0100000000; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff0100000000; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff0100000000; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff0100000000; ++ __m256i_out = __lasx_xvsubwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe00007f000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffff000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result1) = 0xffff7fff00007f00; ++ *((unsigned long *)&__m256i_result0) = 0xffff000100007fff; ++ __m256i_out = __lasx_xvsubwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op12) = 0x000b8f81b8c840e4; ++ *((unsigned long *)&__m256i_op11) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op10) = 0x000b8f81b8c840e4; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffb3b4; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff5ffff4738; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffb3b4; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff5ffff4738; ++ __m256i_out = __lasx_xvsubwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00009fff9ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff20010001; ++ *((unsigned long *)&__m256i_op01) = 0x00009fff9ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff20010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00002080df5b41cf; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00002080df5b41cf; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000009fff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff40a6; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000009fff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff40a6; ++ __m256i_out = __lasx_xvsubwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00007fffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00007fffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff8001; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff8001; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000001; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010000; ++ *((unsigned long *)&__m256i_op02) = 0x020afefb08140000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256i_op13) = 0xffff00ffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff0001ff02; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff020afefc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000003fefd; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op02) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op00) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op13) = 0x1514151415141514; ++ *((unsigned long *)&__m256i_op12) = 0x151415141514e335; ++ *((unsigned long *)&__m256i_op11) = 0x1514151415141514; ++ *((unsigned long *)&__m256i_op10) = 0x151415141514e335; ++ *((unsigned long *)&__m256i_result3) = 0x00000000e9ece9ec; ++ *((unsigned long *)&__m256i_result2) = 0x00000000e9ece9ec; ++ *((unsigned long *)&__m256i_result1) = 0x00000000e9ece9ec; ++ *((unsigned long *)&__m256i_result0) = 0x00000000e9ece9ec; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0008000800080008; ++ *((unsigned long *)&__m256i_op02) = 0x000c005e000c0029; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0004005600040020; ++ *((unsigned long *)&__m256i_op13) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000300000002; ++ *((unsigned long *)&__m256i_op11) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000300000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000060008; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000c005b; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffe0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000040053; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f8f7f8f800f800; ++ *((unsigned long *)&__m256i_op02) = 0x00003f784000ff80; ++ *((unsigned long *)&__m256i_op01) = 0xf7f8f7f84000fff9; ++ *((unsigned long *)&__m256i_op00) = 0x00003f784000ff80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000f7f8f7f8; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000003f78; ++ *((unsigned long *)&__m256i_result1) = 0x00000000f7f8f7f8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000003f78; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op12) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000070007000; ++ *((unsigned long *)&__m256i_op10) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff8fff9000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff8fff9000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff8fff9000; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op12) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_op11) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op10) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff37b737b8; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff77b737b8; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff37b737b8; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff77b737b8; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op02) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op01) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op00) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff457db03f; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsubwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000001; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op13) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op12) = 0x000b2673a90896a4; ++ *((unsigned long *)&__m256i_op11) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op10) = 0x000b2673a90896a4; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffafafb3b3dc9d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffafafb3b3dc9d; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op02) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op00) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000008050501; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000029170; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000029170; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001fff000; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000090b0906; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsubwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvabsd-xvavg-xvav.patch
Added
@@ -0,0 +1,5595 @@ +From 02a3c7b1dc6b66bad2d7eca396176cb9fd731a79 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:42:49 +0800 +Subject: PATCH 115/124 LoongArch: Add tests for ASX vector + xvabsd/xvavg/xvavgr/xvbsll/xvbsrl/xvneg/ xvsat instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvabsd-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvabsd-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvavg-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvavg-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvavgr-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvavgr-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbsll_v.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbsrl_v.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvneg.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsat-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsat-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvabsd-1.c | 485 +++++++++++ + .../loongarch/vector/lasx/lasx-xvabsd-2.c | 650 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvavg-1.c | 680 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvavg-2.c | 560 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvavgr-1.c | 770 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvavgr-2.c | 650 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvbsll_v.c | 130 +++ + .../loongarch/vector/lasx/lasx-xvbsrl_v.c | 64 ++ + .../loongarch/vector/lasx/lasx-xvneg.c | 526 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvsat-1.c | 537 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvsat-2.c | 427 ++++++++++ + 11 files changed, 5479 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsll_v.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsrl_v.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvneg.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-1.c +new file mode 100644 +index 000000000..41fae32df +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-1.c +@@ -0,0 +1,485 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x34598d0fd19314cb; ++ *((unsigned long *)&__m256i_op02) = 0x1820939b2280fa86; ++ *((unsigned long *)&__m256i_op01) = 0x4a1c269b8e892a3a; ++ *((unsigned long *)&__m256i_op00) = 0x063f2bb758abc664; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffc0fcffffcf83; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000288a00003c1c; ++ *((unsigned long *)&__m256i_result3) = 0x3459730f2f6d1435; ++ *((unsigned long *)&__m256i_result2) = 0x19212d61237f2b03; ++ *((unsigned long *)&__m256i_result1) = 0x4a1c266572772a3a; ++ *((unsigned long *)&__m256i_result0) = 0x063f032d58557648; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007f017f01; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007f017f01; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op02) = 0x000b2673a90896a4; ++ *((unsigned long *)&__m256i_op01) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op00) = 0x000b2673a90896a4; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_result3) = 0x0001504f4c4b2361; ++ *((unsigned long *)&__m256i_result2) = 0x303338a48f374969; ++ *((unsigned long *)&__m256i_result1) = 0x0001504f4c4b2361; ++ *((unsigned long *)&__m256i_result0) = 0x303338a48f374969; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x807c7fffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x80817fff00810000; ++ *((unsigned long *)&__m256i_op01) = 0x807c7fffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x80817fff00810000; ++ *((unsigned long *)&__m256i_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op12) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op10) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x80767f0101050101; ++ *((unsigned long *)&__m256i_result2) = 0x80817f01007f0000; ++ *((unsigned long *)&__m256i_result1) = 0x80767f0101050101; ++ *((unsigned long *)&__m256i_result0) = 0x80817f01007f0000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x437fe01fe01fe020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x437fe01fe01fe020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x037fe01f001fe020; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x037fe01f001fe020; ++ *((unsigned long *)&__m256i_result3) = 0x437f201f201f2020; ++ *((unsigned long *)&__m256i_result2) = 0x037f201f001f2020; ++ *((unsigned long *)&__m256i_result1) = 0x437f201f201f2020; ++ *((unsigned long *)&__m256i_result0) = 0x037f201f001f2020; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1f60010000080100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1f60010000080100; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0000010100020103; ++ *((unsigned long *)&__m256i_result2) = 0x040f040f040b236d; ++ *((unsigned long *)&__m256i_result1) = 0x0000010100020103; ++ *((unsigned long *)&__m256i_result0) = 0x040f040f040b236d; ++ __m256i_out = __lasx_xvabsd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100010080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100010080; ++ __m256i_out = __lasx_xvabsd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op02) = 0x0000000073333333; ++ *((unsigned long *)&__m256i_op01) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op00) = 0x0000000073333333; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_result2) = 0x0000000073333333; ++ *((unsigned long *)&__m256i_result1) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_result0) = 0x0000000073333333; ++ __m256i_out = __lasx_xvabsd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000050fd00000101; ++ *((unsigned long *)&__m256i_op12) = 0x000040c100000101; ++ *((unsigned long *)&__m256i_op11) = 0x000050fd00000101; ++ *((unsigned long *)&__m256i_op10) = 0x000040c100000101; ++ *((unsigned long *)&__m256i_result3) = 0x000050fd00000101; ++ *((unsigned long *)&__m256i_result2) = 0x000040c100000101; ++ *((unsigned long *)&__m256i_result1) = 0x000050fd00000101; ++ *((unsigned long *)&__m256i_result0) = 0x000040c100000101; ++ __m256i_out = __lasx_xvabsd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x01ffff4300fffeff; ++ *((unsigned long *)&__m256i_op12) = 0xfe0000bcff000100; ++ *((unsigned long *)&__m256i_op11) = 0x01ffff4300fffeff; ++ *((unsigned long *)&__m256i_op10) = 0xfe0000bcff000100; ++ *((unsigned long *)&__m256i_result3) = 0x81ff00bd80ff0101; ++ *((unsigned long *)&__m256i_result2) = 0x01ff00bd00ff0101; ++ *((unsigned long *)&__m256i_result1) = 0x81ff00bd80ff0101; ++ *((unsigned long *)&__m256i_result0) = 0x01ff00bd00ff0101; ++ __m256i_out = __lasx_xvabsd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op13) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op12) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_op11) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op10) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_result3) = 0x00003fea00013feb; ++ *((unsigned long *)&__m256i_result2) = 0x00003fe900014022; ++ *((unsigned long *)&__m256i_result1) = 0x00003fea00013feb; ++ *((unsigned long *)&__m256i_result0) = 0x00003fe900014022; ++ __m256i_out = __lasx_xvabsd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0cc08723ff900001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xcc9b89f2f6cef440; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0cc08723006fffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x3364760e09310bc0; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op12) = 0x0000017f0000017d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op10) = 0x0000017f0000017f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result2) = 0x0000017f0000017d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result0) = 0x0000017f0000017f; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00fe01f000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00fe01f000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xbf800000bf800000; ++ *((unsigned long *)&__m256i_op12) = 0xd662fa0000000000; ++ *((unsigned long *)&__m256i_op11) = 0xbf800000bf800000; ++ *((unsigned long *)&__m256i_op10) = 0xd6ef750000000000; ++ *((unsigned long *)&__m256i_result3) = 0x417e01f040800000; ++ *((unsigned long *)&__m256i_result2) = 0x299d060000000000; ++ *((unsigned long *)&__m256i_result1) = 0x417e01f040800000; ++ *((unsigned long *)&__m256i_result0) = 0x29108b0000000000; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op12) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op10) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result2) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result0) = 0x0000001700170017; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffb79fb74; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffb79fb74; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_result3) = 0x000100010485048a; ++ *((unsigned long *)&__m256i_result2) = 0x0005ff870005ff86; ++ *((unsigned long *)&__m256i_result1) = 0x000100010485048a; ++ *((unsigned long *)&__m256i_result0) = 0x0005ff870005ff86; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op12) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op11) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op10) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_result2) = 0x0000400100004001; ++ *((unsigned long *)&__m256i_result1) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_result0) = 0x0000400100004001; ++ __m256i_out = __lasx_xvabsd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000000; ++ __m256i_out = __lasx_xvabsd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvabsd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-2.c +new file mode 100644 +index 000000000..bd7a9069d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvabsd-2.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_op02) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_op01) = 0x0008000001010000; ++ *((unsigned long *)&__m256i_op00) = 0x0101000001010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_result2) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_result1) = 0x0008000001010000; ++ *((unsigned long *)&__m256i_result0) = 0x0101000001010000; ++ __m256i_out = __lasx_xvabsd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000100010485048a; ++ *((unsigned long *)&__m256i_op02) = 0x0005ff870005ff86; ++ *((unsigned long *)&__m256i_op01) = 0x000100010485048a; ++ *((unsigned long *)&__m256i_op00) = 0x0005ff870005ff86; ++ *((unsigned long *)&__m256i_op13) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op12) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op11) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op10) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result3) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_result2) = 0xfffa0065fffa0066; ++ *((unsigned long *)&__m256i_result1) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_result0) = 0xfffa0065fffa0066; ++ __m256i_out = __lasx_xvabsd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out = __lasx_xvabsd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvabsd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op12) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op11) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op10) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_result3) = 0x400040003abf4000; ++ *((unsigned long *)&__m256i_result2) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_result1) = 0x400040003abf4000; ++ *((unsigned long *)&__m256i_result0) = 0x000000003fff3fff; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0408040800008003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0408040800008003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fff80800; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0408040800008003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x04080408fff87803; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0606060606060606; ++ *((unsigned long *)&__m256i_op12) = 0x0606060606060606; ++ *((unsigned long *)&__m256i_op11) = 0x0606060606060606; ++ *((unsigned long *)&__m256i_op10) = 0x0606060606060606; ++ *((unsigned long *)&__m256i_result3) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result2) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result1) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result0) = 0xf9f9f9f9f9f9f9f9; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0001; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff003f003f00; ++ *((unsigned long *)&__m256i_op02) = 0xff0101fd00010100; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff003f003f00; ++ *((unsigned long *)&__m256i_op00) = 0xff0101fd00010100; ++ *((unsigned long *)&__m256i_op13) = 0xff00ff003f003f00; ++ *((unsigned long *)&__m256i_op12) = 0xff0101fd00010100; ++ *((unsigned long *)&__m256i_op11) = 0xff00ff003f003f00; ++ *((unsigned long *)&__m256i_op10) = 0xff0101fd00010100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000a0008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000a0008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffff5fff7; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffff5fff7; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001010000; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_op12) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_op11) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_op10) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result3) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result2) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result1) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result0) = 0x0000001400000014; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfbba01c0003f7e3f; ++ *((unsigned long *)&__m256i_op12) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_op11) = 0xfbd884e7003f7e3f; ++ *((unsigned long *)&__m256i_op10) = 0xff874dc687870000; ++ *((unsigned long *)&__m256i_result3) = 0xfbba01c0003f7e3f; ++ *((unsigned long *)&__m256i_result2) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_result1) = 0xfbd884e7003f7e3f; ++ *((unsigned long *)&__m256i_result0) = 0xff874dc687870000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x800000007fff0001; ++ *((unsigned long *)&__m256i_result2) = 0x80000000ff7f0001; ++ *((unsigned long *)&__m256i_result1) = 0x800000007fff0001; ++ *((unsigned long *)&__m256i_result0) = 0x80000000ff7f0001; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op02) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op01) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op00) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_result2) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_result1) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_result0) = 0x01fe01fe01fe01fe; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result2) = 0x0000010000080040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000080040; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffffd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffffe; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00040000; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003f3f0000400d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003f3f0000400d; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffff88; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffe98; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000064; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7f80ffffff808000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7f80ffffff808000; ++ *((unsigned long *)&__m256i_result3) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_result2) = 0x007f0000007f7fff; ++ *((unsigned long *)&__m256i_result1) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_result0) = 0x007f0000007f7fff; ++ __m256i_out = __lasx_xvabsd_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-1.c +new file mode 100644 +index 000000000..5ce31ebbd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-1.c +@@ -0,0 +1,680 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000001f; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x000100da000100fd; ++ *((unsigned long *)&__m256i_op12) = 0x0001ffe20001fefd; ++ *((unsigned long *)&__m256i_op11) = 0x0001009a000100fd; ++ *((unsigned long *)&__m256i_op10) = 0x0001ff640001fefd; ++ *((unsigned long *)&__m256i_result3) = 0x000000edff00fffd; ++ *((unsigned long *)&__m256i_result2) = 0x0000fff10000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000cdff00fffd; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff320000ffff; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_op13) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op11) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_result3) = 0xfffe00f7ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffff629d7; ++ *((unsigned long *)&__m256i_result1) = 0xfffe00f7ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffff629d7; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xd010101010101010; ++ *((unsigned long *)&__m256i_result2) = 0xd010101010103218; ++ *((unsigned long *)&__m256i_result1) = 0xd010101010101010; ++ *((unsigned long *)&__m256i_result0) = 0xd010101010103218; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op02) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op01) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op00) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000400100013; ++ *((unsigned long *)&__m256i_result2) = 0x0000000400100014; ++ *((unsigned long *)&__m256i_result1) = 0x0000000400100013; ++ *((unsigned long *)&__m256i_result0) = 0x0000000400000004; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_op11) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavg_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op01) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256i_op11) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256i_result1) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00010002; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op12) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op10) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result3) = 0x0008000800080008; ++ *((unsigned long *)&__m256i_result2) = 0x0008000800080008; ++ *((unsigned long *)&__m256i_result1) = 0x0008000800080008; ++ *((unsigned long *)&__m256i_result0) = 0x0008000800080008; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result3) = 0x1010101010101013; ++ *((unsigned long *)&__m256i_result2) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result1) = 0x1010101010101013; ++ *((unsigned long *)&__m256i_result0) = 0x1010101010101010; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000006170; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000006170; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000030b8; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op02) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op01) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op00) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op13) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op12) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op11) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op10) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result3) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result2) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result1) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result0) = 0x0202010202020102; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000405; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000405; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000202; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op13) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_op12) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_result3) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_result2) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_result1) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_result0) = 0x0004000500040005; ++ __m256i_out = __lasx_xvavg_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_op12) = 0x00d6c1c830160048; ++ *((unsigned long *)&__m256i_op11) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_op10) = 0xe3aebaf4df958004; ++ *((unsigned long *)&__m256i_result3) = 0xc58a0a0a07070706; ++ *((unsigned long *)&__m256i_result2) = 0x006b60e4180b0023; ++ *((unsigned long *)&__m256i_result1) = 0x1b39153f334b966a; ++ *((unsigned long *)&__m256i_result0) = 0xf1d75d79efcac002; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_result2) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_result1) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff00007fff; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffff00000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffff00000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x003fffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x003fffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavg_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007fff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff7fffffff; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0080808080808080; ++ *((unsigned long *)&__m256i_result2) = 0x0080808080808080; ++ *((unsigned long *)&__m256i_result1) = 0x0080808100808080; ++ *((unsigned long *)&__m256i_result0) = 0x0080808000808080; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_op02) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_op01) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_op00) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0888888888888888; ++ *((unsigned long *)&__m256i_result2) = 0x0888888888888888; ++ *((unsigned long *)&__m256i_result1) = 0x0888888888888888; ++ *((unsigned long *)&__m256i_result0) = 0x0888888888888888; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4010000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x3e6ce7d9cb7afb62; ++ *((unsigned long *)&__m256i_op01) = 0x4010000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x3e6ce7d9cb7afb62; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2008000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1f3673ece5bd7db1; ++ *((unsigned long *)&__m256i_result1) = 0x2008000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1f3673ece5bd7db1; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000400000003fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000400000003fff; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000040404000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040404000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000020202000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000020202000; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op12) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op10) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffe00fe00; ++ *((unsigned long *)&__m256i_result2) = 0x000000001fe01dde; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffe00fe00; ++ *((unsigned long *)&__m256i_result0) = 0x000000001fe01dde; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000080040; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op11) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result3) = 0x0020000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0020000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvavg_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-2.c +new file mode 100644 +index 000000000..d04e42753 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavg-2.c +@@ -0,0 +1,560 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_op02) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_op01) = 0x61d849f0c0794ced; ++ *((unsigned long *)&__m256i_op00) = 0xe75278c187b20039; ++ *((unsigned long *)&__m256i_op13) = 0xf90c0c0c00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0ca40c0c0c0c0cc0; ++ *((unsigned long *)&__m256i_op11) = 0x0c0c0c0c0cb60cc0; ++ *((unsigned long *)&__m256i_op10) = 0xfbe0b80c960c96d0; ++ *((unsigned long *)&__m256i_result3) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_result2) = 0x146014141414146e; ++ *((unsigned long *)&__m256i_result1) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_result0) = 0xf19998668e5f4b84; ++ __m256i_out = __lasx_xvavg_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000ffffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff00fff0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000007f7f; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000007f7f; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f007f78; ++ __m256i_out = __lasx_xvavg_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff02ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffff0100; ++ *((unsigned long *)&__m256i_op00) = 0xff00fefffeff02ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00030006fa05f20e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00030081bd80f90e; ++ *((unsigned long *)&__m256i_result3) = 0x00007f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result2) = 0x00010003fc827a86; ++ *((unsigned long *)&__m256i_result1) = 0x00007f7f7f7f0000; ++ *((unsigned long *)&__m256i_result0) = 0x7f017fc0ddbf7d86; ++ __m256i_out = __lasx_xvavg_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op12) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op11) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op10) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result3) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_result2) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_result1) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_result0) = 0x0101000101010001; ++ __m256i_out = __lasx_xvavg_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavg_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x007f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x007f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result0) = 0x7f7f7f7f00000000; ++ __m256i_out = __lasx_xvavg_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000007f00000022; ++ *((unsigned long *)&__m256i_op10) = 0x0000007f00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000003f00000011; ++ *((unsigned long *)&__m256i_result0) = 0x0000003f00000000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3fff3fff3fff3fff; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffbfffafffffffe; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op00) = 0xfffbfffaffff0000; ++ *((unsigned long *)&__m256i_op13) = 0x00fe01fc01fe01fc; ++ *((unsigned long *)&__m256i_op12) = 0x012c002c001c0006; ++ *((unsigned long *)&__m256i_op11) = 0x00fe01fc01fe0000; ++ *((unsigned long *)&__m256i_op10) = 0x012c002c001c000a; ++ *((unsigned long *)&__m256i_result3) = 0x807e80fd80fe80fd; ++ *((unsigned long *)&__m256i_result2) = 0x80938013800d8002; ++ *((unsigned long *)&__m256i_result1) = 0x807e80fd80fe0000; ++ *((unsigned long *)&__m256i_result0) = 0x80938013800d0005; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result3) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x8000800080008000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x3fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result2) = 0x3fff7fffffc08008; ++ *((unsigned long *)&__m256i_result1) = 0x3fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x3fff7fffffc08008; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op13) = 0x800000007fff0001; ++ *((unsigned long *)&__m256i_op12) = 0x80000000ff7f0001; ++ *((unsigned long *)&__m256i_op11) = 0x800000007fff0001; ++ *((unsigned long *)&__m256i_op10) = 0x80000000ff7f0001; ++ *((unsigned long *)&__m256i_result3) = 0x800000007fff0000; ++ *((unsigned long *)&__m256i_result2) = 0x80000000ff7f0000; ++ *((unsigned long *)&__m256i_result1) = 0x800000007fff0000; ++ *((unsigned long *)&__m256i_result0) = 0x80000000ff7f0000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op11) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_result1) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff0000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000004; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op02) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op00) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_result2) = 0x7e00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_result0) = 0x7e00000000000000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00007fff00400011; ++ *((unsigned long *)&__m256i_result2) = 0x000000008001ffff; ++ *((unsigned long *)&__m256i_result1) = 0x00007fff00400011; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a09080706050403; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0a09080706050403; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0504840303028201; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0504840303028201; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000200; ++ __m256i_out = __lasx_xvavg_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000005000000020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000005000000020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000002800000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000002800000010; ++ __m256i_out = __lasx_xvavg_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x40efffe000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x40efffe000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op12) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op11) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op10) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result3) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result2) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result1) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result0) = 0x7f807f007f7f817f; ++ __m256i_out = __lasx_xvavg_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x111ebb784f9c4100; ++ *((unsigned long *)&__m256i_op12) = 0x1c386546809f3b50; ++ *((unsigned long *)&__m256i_op11) = 0x111ebb784f9bf1ac; ++ *((unsigned long *)&__m256i_op10) = 0x21f6050d955d3f68; ++ *((unsigned long *)&__m256i_result3) = 0x088f5dbc27ce2080; ++ *((unsigned long *)&__m256i_result2) = 0x161c32a2c04f9da7; ++ *((unsigned long *)&__m256i_result1) = 0x088f5dbc27cdf8d6; ++ *((unsigned long *)&__m256i_result0) = 0x10fb02864aae9fb4; ++ __m256i_out = __lasx_xvavg_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_op02) = 0xfffe0000fffe0012; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_op00) = 0xfffe0000fffe0012; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_op12) = 0xfffe0000fffe0012; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_op10) = 0xfffe0000fffe0012; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_result2) = 0xfffe0000fffe0012; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_result0) = 0xfffe0000fffe0012; ++ __m256i_out = __lasx_xvavg_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvavg_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_result1) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x0000800080008000; ++ __m256i_out = __lasx_xvavg_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000004444; ++ *((unsigned long *)&__m256i_op12) = 0x00007bbb0000f777; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000004444; ++ *((unsigned long *)&__m256i_op10) = 0x00007bbb0000f777; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_result2) = 0x00003ddd80007bbb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_result0) = 0x00003ddd80007bbb; ++ __m256i_out = __lasx_xvavg_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000f0f0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000f0f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007878; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007878; ++ __m256i_out = __lasx_xvavg_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvavg_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000001e00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000f00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavg_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-1.c +new file mode 100644 +index 000000000..37b78aa1b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-1.c +@@ -0,0 +1,770 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_op02) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op01) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_op00) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff39ffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff39ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x2b2b2b2b1bd5d5d6; ++ *((unsigned long *)&__m256i_result2) = 0x2a2a2a2af2d5d5d6; ++ *((unsigned long *)&__m256i_result1) = 0x2b2b2b2b1bd5d5d6; ++ *((unsigned long *)&__m256i_result0) = 0x2a2a2a2af2d5d5d6; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000c0; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000c0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000c0; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000c0; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_op12) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_op11) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_op10) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000200020; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000200020; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000200020; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000200020; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op12) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op11) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op10) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_result3) = 0x40f23232330df9c8; ++ *((unsigned long *)&__m256i_result2) = 0x40f2323240f23232; ++ *((unsigned long *)&__m256i_result1) = 0x40f23232330df9c8; ++ *((unsigned long *)&__m256i_result0) = 0x40f2323240f23232; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100800000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100c00000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0ff000000000f; ++ *((unsigned long *)&__m256i_op02) = 0x000f00f000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfff0ff000000000f; ++ *((unsigned long *)&__m256i_op00) = 0x000f00f000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00f8000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x000800f800000000; ++ *((unsigned long *)&__m256i_result1) = 0x00f8000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x000800f800000000; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000090b0906; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000005060503; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000073737; ++ __m256i_out = __lasx_xvavgr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xdff8000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xdff8000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xdff8000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xdff8000000000000; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff7f0000ff7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff7f0000ff7f; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x4000000000000000; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000fd0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000fd0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007f0000; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op02) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_op01) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op00) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_result2) = 0xdfc2df80df80df87; ++ *((unsigned long *)&__m256i_result1) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_result0) = 0xdfc2df80df80df87; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op02) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_op01) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op00) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_op13) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op12) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op11) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op10) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result3) = 0xdf80ff20df80ff20; ++ *((unsigned long *)&__m256i_result2) = 0xdfc2ff20df80ffa7; ++ *((unsigned long *)&__m256i_result1) = 0xdf80ff20df80ff20; ++ *((unsigned long *)&__m256i_result0) = 0xdfc2ff20df80ffa7; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000c0000005; ++ *((unsigned long *)&__m256i_result2) = 0x21f8c3c4c0000005; ++ *((unsigned long *)&__m256i_result1) = 0x00000000c0000005; ++ *((unsigned long *)&__m256i_result0) = 0x21f8c3c4c0000005; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op02) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op01) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op00) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_result2) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_result1) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_result0) = 0x8848c848c848c848; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op13) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op12) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_result3) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_result2) = 0x00000080c000c080; ++ *((unsigned long *)&__m256i_result1) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_result0) = 0x00000080c000c080; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3fffffff3fffc000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3fffffff3fffc000; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x003fffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x003fffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x003fffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x003fffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result1) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000007ffffffce; ++ __m256i_out = __lasx_xvavgr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000808081; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000808081; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000808081; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000808081; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000f18080010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000f18080010000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000078c0c0008000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000078c0c0008000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op02) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op01) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op00) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op13) = 0x1086658a18ba3594; ++ *((unsigned long *)&__m256i_op12) = 0x160fe9f000000000; ++ *((unsigned long *)&__m256i_op11) = 0x1086658a18ba3594; ++ *((unsigned long *)&__m256i_op10) = 0x160fe9f000000000; ++ *((unsigned long *)&__m256i_result3) = 0x07a232640bfc1a73; ++ *((unsigned long *)&__m256i_result2) = 0x0a66f497ff9effa9; ++ *((unsigned long *)&__m256i_result1) = 0x07a232640bfc1a73; ++ *((unsigned long *)&__m256i_result0) = 0x0a66f497ff9effa9; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_op13) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op11) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_result3) = 0x007f00f8ff7fff80; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fff6a9d8; ++ *((unsigned long *)&__m256i_result1) = 0x007f00f8ff7fff80; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fff6a9d8; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m256i_op02) = 0x000000007ffe7ffe; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe7ffe7ffe8000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000807e7ffe; ++ *((unsigned long *)&__m256i_op13) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m256i_op12) = 0x000000007ffe7ffe; ++ *((unsigned long *)&__m256i_op11) = 0x7ffe7ffe7ffe8000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000807e7ffe; ++ *((unsigned long *)&__m256i_result3) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m256i_result2) = 0x000000007ffe7ffe; ++ *((unsigned long *)&__m256i_result1) = 0x7ffe7ffe7ffe8000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000807e7ffe; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_result2) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_result1) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_result0) = 0x007f8080007f007f; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op11) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result3) = 0xffe37fe3001d001d; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256i_result1) = 0xffe37fe3001d001d; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff8000; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000f00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000700000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000081; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000004a00000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000004a0000002a; ++ *((unsigned long *)&__m256i_op01) = 0x0000004a00000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000004a0000002a; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000fffffffefffe; ++ *((unsigned long *)&__m256i_op11) = 0xff7fffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000fffffffefffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000002500000020; ++ *((unsigned long *)&__m256i_result2) = 0x00008024ffff8014; ++ *((unsigned long *)&__m256i_result1) = 0xffc0002500000020; ++ *((unsigned long *)&__m256i_result0) = 0x00008024ffff8014; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000001a00; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000023a20000a121; ++ *((unsigned long *)&__m256i_op02) = 0x0000179e0000951d; ++ *((unsigned long *)&__m256i_op01) = 0x000023a20000a121; ++ *((unsigned long *)&__m256i_op00) = 0x0000179e0000951d; ++ *((unsigned long *)&__m256i_op13) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op12) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op10) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000125100005111; ++ *((unsigned long *)&__m256i_result2) = 0x00000c4f00004b0f; ++ *((unsigned long *)&__m256i_result1) = 0x0000125100005111; ++ *((unsigned long *)&__m256i_result0) = 0x00000c4f00004b0f; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000080008001; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000457d607d; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff457d607f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000457d607d; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff457d607f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffa2beb040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffa2beb040; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000005858585a; ++ *((unsigned long *)&__m256i_op02) = 0x000000005858585a; ++ *((unsigned long *)&__m256i_op01) = 0x000000005858585a; ++ *((unsigned long *)&__m256i_op00) = 0x000000005858585a; ++ *((unsigned long *)&__m256i_op13) = 0x000023a300003fff; ++ *((unsigned long *)&__m256i_op12) = 0x000023a300003fef; ++ *((unsigned long *)&__m256i_op11) = 0x000023a300003fff; ++ *((unsigned long *)&__m256i_op10) = 0x000023a300003fef; ++ *((unsigned long *)&__m256i_result3) = 0x000011d1ac2c4c2d; ++ *((unsigned long *)&__m256i_result2) = 0x000011d1ac2c4c25; ++ *((unsigned long *)&__m256i_result1) = 0x000011d1ac2c4c2d; ++ *((unsigned long *)&__m256i_result0) = 0x000011d1ac2c4c25; ++ __m256i_out = __lasx_xvavgr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-2.c +new file mode 100644 +index 000000000..3944a6ac0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvavgr-2.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result2) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result0) = 0x8080808080808080; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result2) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result0) = 0x8080808080808080; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000018803100188; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000018803100188; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000014402080144; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000086fe0000403e; ++ *((unsigned long *)&__m256i_op12) = 0x0000403e00004040; ++ *((unsigned long *)&__m256i_op11) = 0x000086fe0000403e; ++ *((unsigned long *)&__m256i_op10) = 0x0000403e00004040; ++ *((unsigned long *)&__m256i_result3) = 0x0000437f0000201f; ++ *((unsigned long *)&__m256i_result2) = 0x0000201f00002020; ++ *((unsigned long *)&__m256i_result1) = 0x0000437f0000201f; ++ *((unsigned long *)&__m256i_result0) = 0x0000201f00002020; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x90007fff90008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0ffffffe90008000; ++ *((unsigned long *)&__m256i_result3) = 0x87ffffff87ffffff; ++ *((unsigned long *)&__m256i_result2) = 0xc880bfffc880c080; ++ *((unsigned long *)&__m256i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result0) = 0x87ffffffc880c080; ++ __m256i_out = __lasx_xvavgr_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op01) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op13) = 0x0000000082a54290; ++ *((unsigned long *)&__m256i_op12) = 0x00000000028aa700; ++ *((unsigned long *)&__m256i_op11) = 0x0000000082a54290; ++ *((unsigned long *)&__m256i_op10) = 0x0000000002a54287; ++ *((unsigned long *)&__m256i_result3) = 0x007f00f841532148; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001a753c3; ++ *((unsigned long *)&__m256i_result1) = 0x007f00f841532148; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001b52187; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000004444; ++ *((unsigned long *)&__m256i_op12) = 0x00007bbb0000f777; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000004444; ++ *((unsigned long *)&__m256i_op10) = 0x00007bbb0000f777; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_result2) = 0x00003dde00007bbc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_result0) = 0x00003dde00007bbc; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op12) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op11) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op10) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result3) = 0x4ffc3f783fc040c0; ++ *((unsigned long *)&__m256i_result2) = 0x3fc03f803fc040c0; ++ *((unsigned long *)&__m256i_result1) = 0x4ffc3f783fc040c0; ++ *((unsigned long *)&__m256i_result0) = 0x3fc03f803fc040c0; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0505070804040404; ++ *((unsigned long *)&__m256i_op02) = 0x0504070804040404; ++ *((unsigned long *)&__m256i_op01) = 0x0505070804040404; ++ *((unsigned long *)&__m256i_op00) = 0x0504070804040404; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0283038402020202; ++ *((unsigned long *)&__m256i_result2) = 0x0282038402020202; ++ *((unsigned long *)&__m256i_result1) = 0x0283038402020202; ++ *((unsigned long *)&__m256i_result0) = 0x0282038402020202; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1010101010001000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x101010100000000e; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0889088908810881; ++ *((unsigned long *)&__m256i_result2) = 0x0081010000810100; ++ *((unsigned long *)&__m256i_result1) = 0x0889088900810088; ++ *((unsigned long *)&__m256i_result0) = 0x0081010000810100; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000001d001d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000080008000; ++ *((unsigned long *)&__m256i_result2) = 0x3e00000440004000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000080008000; ++ *((unsigned long *)&__m256i_result0) = 0x3e000004400f400f; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_op13) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x3abb3abbbabababa; ++ *((unsigned long *)&__m256i_result2) = 0x0080000000800080; ++ *((unsigned long *)&__m256i_result1) = 0x3abb3abbbabababa; ++ *((unsigned long *)&__m256i_result0) = 0x0080000000800080; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xc0008000c0008000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xc0008000c0008000; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100020001; ++ *((unsigned long *)&__m256i_op00) = 0x0000fffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_op12) = 0x00d6c1c830160048; ++ *((unsigned long *)&__m256i_op11) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_op10) = 0xe3aebaf4df958004; ++ *((unsigned long *)&__m256i_result3) = 0xc5890a0a07070707; ++ *((unsigned long *)&__m256i_result2) = 0x006be0e4180b8024; ++ *((unsigned long *)&__m256i_result1) = 0x1b399540334c966c; ++ *((unsigned long *)&__m256i_result0) = 0x71d7dd7aefcac001; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000808080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080404040; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op02) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op01) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op00) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_result3) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_result2) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_result1) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_result0) = 0x000a800b000a800b; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00f9f9f900000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00f9f9f900000002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007cfcfd80000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007cfcfd80000001; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff8001ffff8001; ++ *((unsigned long *)&__m256i_op11) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff8001ffff8001; ++ *((unsigned long *)&__m256i_result3) = 0x7fff800000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffc0017fffc001; ++ *((unsigned long *)&__m256i_result1) = 0x7fff800000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffc0017fffc001; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0080000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0080000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000000a; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000000a; ++ *((unsigned long *)&__m256i_result3) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result1) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000005; ++ __m256i_out = __lasx_xvavgr_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256i_op02) = 0xc5c085372cfabfba; ++ *((unsigned long *)&__m256i_op01) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256i_op00) = 0x0658f2dc0eb21e3c; ++ *((unsigned long *)&__m256i_op13) = 0x000000000501e99b; ++ *((unsigned long *)&__m256i_op12) = 0x0000000109973de7; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001020f22; ++ *((unsigned long *)&__m256i_op10) = 0x00000001890b7a39; ++ *((unsigned long *)&__m256i_result3) = 0x1b974ebaf6d64d4e; ++ *((unsigned long *)&__m256i_result2) = 0x62e0429c1b48fed1; ++ *((unsigned long *)&__m256i_result1) = 0x18b985adf63f548c; ++ *((unsigned long *)&__m256i_result0) = 0x032c796ecbdecc3b; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3a2a3a2a3a2a3a2a; ++ *((unsigned long *)&__m256i_op02) = 0x3a2a3a2a3aaa45aa; ++ *((unsigned long *)&__m256i_op01) = 0x3a553f7f7a2a3a2a; ++ *((unsigned long *)&__m256i_op00) = 0x3a2a3a2a3aaa45aa; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_op11) = 0x017e00ff017e00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_result3) = 0x1d949d949d949d95; ++ *((unsigned long *)&__m256i_result2) = 0x1d949d949e1423d4; ++ *((unsigned long *)&__m256i_result1) = 0x1de9a03f3dd41d95; ++ *((unsigned long *)&__m256i_result0) = 0x1d949d949e1423d4; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000083f95466; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0101010100005400; ++ *((unsigned long *)&__m256i_op13) = 0x001e001ea1bfa1bf; ++ *((unsigned long *)&__m256i_op12) = 0x001e001e83e5422e; ++ *((unsigned long *)&__m256i_op11) = 0x001e001ea1bfa1bf; ++ *((unsigned long *)&__m256i_op10) = 0x011f011f0244420e; ++ *((unsigned long *)&__m256i_result3) = 0x000f000fd0dfd0df; ++ *((unsigned long *)&__m256i_result2) = 0x000f000f83ef4b4a; ++ *((unsigned long *)&__m256i_result1) = 0x000f000fd0dfd0df; ++ *((unsigned long *)&__m256i_result0) = 0x0110011001224b07; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000030000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000030000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000018002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000018002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x223d76f09f3881ff; ++ *((unsigned long *)&__m256i_op12) = 0x3870ca8d013e76a0; ++ *((unsigned long *)&__m256i_op11) = 0x223d76f09f37e357; ++ *((unsigned long *)&__m256i_op10) = 0x43ec0a1b2aba7ed0; ++ *((unsigned long *)&__m256i_result3) = 0x111ebb784f9c4100; ++ *((unsigned long *)&__m256i_result2) = 0x1c386546809f3b50; ++ *((unsigned long *)&__m256i_result1) = 0x111ebb784f9bf1ac; ++ *((unsigned long *)&__m256i_result0) = 0x21f6050d955d3f68; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000840100000000; ++ *((unsigned long *)&__m256i_op12) = 0xbffebffec0fe0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000840100000000; ++ *((unsigned long *)&__m256i_op10) = 0xbffebffec0fe0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_result2) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_result0) = 0x5fff5fff607f0000; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000457d607d; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff457d607f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000457d607d; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff457d607f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffa2beb040; ++ __m256i_out = __lasx_xvavgr_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsll_v.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsll_v.c +new file mode 100644 +index 000000000..3c1a8b8e6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsll_v.c +@@ -0,0 +1,130 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_result3) = 0x00555555553f8000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00555555553f8000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000030000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000030000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020643100000000; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020643100000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op02) = 0x000b2673a90896a4; ++ *((unsigned long *)&__m256i_op01) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op00) = 0x000b2673a90896a4; ++ *((unsigned long *)&__m256i_result3) = 0xa90896a400000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xa90896a400000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x003f003f003f0040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x003f003f003f0040; ++ *((unsigned long *)&__m256i_result3) = 0x00003f003f003f00; ++ *((unsigned long *)&__m256i_result2) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00003f003f003f00; ++ *((unsigned long *)&__m256i_result0) = 0x4000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsll_v (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsrl_v.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsrl_v.c +new file mode 100644 +index 000000000..340f7691b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbsrl_v.c +@@ -0,0 +1,64 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000007d0d0d0; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000007d0d0d0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000007d0d0d00000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000007d0d0d00000; ++ __m256i_out = __lasx_xvbsrl_v (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000001fffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fffffffe; ++ *((unsigned long *)&__m256i_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01fffffffe000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01fffffffe000000; ++ __m256i_out = __lasx_xvbsrl_v (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000018803100188; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000018803100188; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbsrl_v (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbsrl_v (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvneg.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvneg.c +new file mode 100644 +index 000000000..3cd1626d4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvneg.c +@@ -0,0 +1,526 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x002e4db200000000; ++ *((unsigned long *)&__m256i_op02) = 0x000315ac0000d658; ++ *((unsigned long *)&__m256i_op01) = 0x00735278007cf94c; ++ *((unsigned long *)&__m256i_op00) = 0x0003ed8800031b38; ++ *((unsigned long *)&__m256i_result3) = 0xffd1b24e00000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffcea54ffff29a8; ++ *((unsigned long *)&__m256i_result1) = 0xff8cad88ff8306b4; ++ *((unsigned long *)&__m256i_result0) = 0xfffc1278fffce4c8; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000ffff8000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x06f880008000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800080008000b8f1; ++ *((unsigned long *)&__m256i_result3) = 0x8000010180000101; ++ *((unsigned long *)&__m256i_result2) = 0xfa08800080000101; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x800080008000480f; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010102; ++ *((unsigned long *)&__m256i_result2) = 0x0101010201010204; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010102; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010102; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010203; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff0e400; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007380; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000f1c00; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000800000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op02) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op01) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op00) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0081000100810001; ++ *((unsigned long *)&__m256i_result2) = 0x0081000100810001; ++ *((unsigned long *)&__m256i_result1) = 0x0081000100810001; ++ *((unsigned long *)&__m256i_result0) = 0x0081000100810001; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x223d76f09f3881ff; ++ *((unsigned long *)&__m256i_op02) = 0x3870ca8d013e76a0; ++ *((unsigned long *)&__m256i_op01) = 0x223d76f09f37e357; ++ *((unsigned long *)&__m256i_op00) = 0x43ec0a1b2aba7ed0; ++ *((unsigned long *)&__m256i_result3) = 0xdec38a1061c87f01; ++ *((unsigned long *)&__m256i_result2) = 0xc8903673ffc28a60; ++ *((unsigned long *)&__m256i_result1) = 0xdec38a1061c91da9; ++ *((unsigned long *)&__m256i_result0) = 0xbd14f6e5d6468230; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000007e8080; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fdda7dc4; ++ *((unsigned long *)&__m256i_op01) = 0x00000000007e8080; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fdda7dc4; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff827f80; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0226823c; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff827f80; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0226823c; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000180000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000180000001; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000001; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfff1000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff1000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op02) = 0x000000008000165a; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op00) = 0x000000008000165a; ++ *((unsigned long *)&__m256i_result3) = 0xffff00017fff005d; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffe9a6; ++ *((unsigned long *)&__m256i_result1) = 0xffff00017fff005d; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffe9a6; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f7f7f7f7f8; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f7f7f7f7f8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffff0100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffff0100000001; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op02) = 0x0100004300000000; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op00) = 0x0100004300000000; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result2) = 0xff0000bd00000000; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result0) = 0xff0000bd00000000; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op02) = 0x0000010000080040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op00) = 0x0000010000080040; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff00fff8ffc0; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000497fe0000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000683fe0000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000497fe0000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000683fe0000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffb6811fffff80; ++ *((unsigned long *)&__m256i_result2) = 0xffff97c120000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffb6811fffff80; ++ *((unsigned long *)&__m256i_result0) = 0xffff97c120000000; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfefefefefdfdfdfd; ++ *((unsigned long *)&__m256i_op02) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op01) = 0xfefefefefdfdfdfd; ++ *((unsigned long *)&__m256i_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result3) = 0x0101010202020203; ++ *((unsigned long *)&__m256i_result2) = 0x0101010201010102; ++ *((unsigned long *)&__m256i_result1) = 0x0101010202020203; ++ *((unsigned long *)&__m256i_result0) = 0x0101010201010102; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000032; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000032; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffce; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffce; ++ __m256i_out = __lasx_xvneg_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvneg_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00007fde00007fd4; ++ *((unsigned long *)&__m256i_op02) = 0x00007fe000007fe0; ++ *((unsigned long *)&__m256i_op01) = 0x00007fde00007fd4; ++ *((unsigned long *)&__m256i_op00) = 0x00007fe000007fe0; ++ *((unsigned long *)&__m256i_result3) = 0x000081220000812c; ++ *((unsigned long *)&__m256i_result2) = 0x0000812000008120; ++ *((unsigned long *)&__m256i_result1) = 0x000081220000812c; ++ *((unsigned long *)&__m256i_result0) = 0x0000812000008120; ++ __m256i_out = __lasx_xvneg_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffd880; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffd880; ++ __m256i_out = __lasx_xvneg_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-1.c +new file mode 100644 +index 000000000..b4ac50271 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-1.c +@@ -0,0 +1,537 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000800080000000; ++ *((unsigned long *)&__m256i_op01) = 0xc9d8080067f50020; ++ *((unsigned long *)&__m256i_op00) = 0xc70000020000c000; ++ *((unsigned long *)&__m256i_result3) = 0xf000f00000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000f000f0000000; ++ *((unsigned long *)&__m256i_result1) = 0xf0f008000ff5000f; ++ *((unsigned long *)&__m256i_result0) = 0xf00000020000f000; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000fff8; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000e000e000e000e; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00003fea00013fec; ++ *((unsigned long *)&__m256i_op02) = 0x00003fe50001c013; ++ *((unsigned long *)&__m256i_op01) = 0x00003fea00013fec; ++ *((unsigned long *)&__m256i_op00) = 0x00003fe50001c013; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff0000ff00; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff0000ff00; ++ __m256i_out = __lasx_xvsat_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000399400003994; ++ *((unsigned long *)&__m256i_op02) = 0x0000399400003994; ++ *((unsigned long *)&__m256i_op01) = 0x0000399400003994; ++ *((unsigned long *)&__m256i_op00) = 0x0000399400003994; ++ *((unsigned long *)&__m256i_result3) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256i_result2) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256i_result1) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256i_result0) = 0x00000fff00000fff; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op02) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op01) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op00) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_result3) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_result2) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_result1) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_result0) = 0xffc0ffc0ffc0ffc0; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00002df900001700; ++ *((unsigned long *)&__m256i_op02) = 0xfffffe05ffffe911; ++ *((unsigned long *)&__m256i_op01) = 0x00002df900001700; ++ *((unsigned long *)&__m256i_op00) = 0xfffffe05ffffe911; ++ *((unsigned long *)&__m256i_result3) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffcfffffffc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffcfffffffc; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffdd97dc4; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffdd97dc4; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffdd97dc4; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffdd97dc4; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000007f007f007f; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000003fffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000003fffff; ++ __m256i_out = __lasx_xvsat_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0002000200000022; ++ *((unsigned long *)&__m256i_op00) = 0x0049004200000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000007f00000022; ++ *((unsigned long *)&__m256i_result0) = 0x0000007f00000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffefffffefd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffefffffefd; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op02) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_op01) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op00) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_result3) = 0x007fffff007fffff; ++ *((unsigned long *)&__m256i_result2) = 0x007fffff007fffff; ++ *((unsigned long *)&__m256i_result1) = 0x007fffff007fffff; ++ *((unsigned long *)&__m256i_result0) = 0x007fffff007fffff; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001ffff0001ffff; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000080000001000; ++ *((unsigned long *)&__m256i_op02) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op01) = 0x0000080000001000; ++ *((unsigned long *)&__m256i_op00) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result3) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000f0000000f; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op02) = 0x000b8f81b8c840e4; ++ *((unsigned long *)&__m256i_op01) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op00) = 0x000b8f81b8c840e4; ++ *((unsigned long *)&__m256i_result3) = 0x000007ff000007ff; ++ *((unsigned long *)&__m256i_result2) = 0x000007fffffff800; ++ *((unsigned long *)&__m256i_result1) = 0x000007ff000007ff; ++ *((unsigned long *)&__m256i_result0) = 0x000007fffffff800; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_w (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_op02) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_op01) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_op00) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffc00000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffc00000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffc00000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffc00000000; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x22); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff605a; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff605a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff605a; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff605a; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256i_op02) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffff8d9ffa7103d; ++ *((unsigned long *)&__m256i_result3) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256i_result2) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffff8d9ffa7103d; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x39); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x21); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op02) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op01) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op00) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result3) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffe000000000000; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x31); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000001ffffffff; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x21); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op02) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op01) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op00) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result3) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0fffffffffffffff; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff8; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000002c21ffeff; ++ *((unsigned long *)&__m256i_op02) = 0xc0000000c0000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000002c21ffeff; ++ *((unsigned long *)&__m256i_op00) = 0xc0000000c0000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff8; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_d (__m256i_op0, 0x32); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-2.c +new file mode 100644 +index 000000000..e5ee89deb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsat-2.c +@@ -0,0 +1,427 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x3f3f3f3f3f3f3f3f; ++ *((unsigned long *)&__m256i_result2) = 0x3f3f3f3f3f3f3f3f; ++ *((unsigned long *)&__m256i_result1) = 0x000000003f3f3f3f; ++ *((unsigned long *)&__m256i_result0) = 0x3f3f3f3f00000000; ++ __m256i_out = __lasx_xvsat_bu (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_bu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvsat_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000017f7f7f; ++ *((unsigned long *)&__m256i_result2) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000017f7f7f; ++ *((unsigned long *)&__m256i_result0) = 0x7f00000000000000; ++ __m256i_out = __lasx_xvsat_bu (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_op02) = 0x0007ffff0007ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_op00) = 0x0007ffff0007ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_result2) = 0x00071f1f00071f1f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_result0) = 0x00071f1f00071f1f; ++ __m256i_out = __lasx_xvsat_bu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d6d6d; ++ __m256i_out = __lasx_xvsat_bu (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result2) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_result1) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result0) = 0x000000003fff3fff; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result2) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result1) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result0) = 0x001f001f001f001f; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result2) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result1) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result0) = 0x00001fff00001fff; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000003f003f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000003f003f; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xc0090000c0200060; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xc0090000c0200060; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007f0000007f0060; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256i_op02) = 0x408480007fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256i_op00) = 0x408480007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_result2) = 0x0003000300030000; ++ *((unsigned long *)&__m256i_result1) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_result0) = 0x0003000300030000; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000029170; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000029170; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000203ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000203ff; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_hu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op02) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op01) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op00) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_result3) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000f0000000f; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000077fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003fe000000000; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffcfffc; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffcfffc; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fffcfffc; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffcfffc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000003fff; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op02) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0fffffff0fffffff; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffe000ffffffff08; ++ *((unsigned long *)&__m256i_op01) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffe000ffffffff08; ++ *((unsigned long *)&__m256i_result3) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0fffffff0fffffff; ++ __m256i_out = __lasx_xvsat_wu (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000003ffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x000003ffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x000003ffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x000003ffffffffff; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x29); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x34); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x0001ffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_result1) = 0x0001ffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x30); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_op02) = 0x2475cef801f0ffdd; ++ *((unsigned long *)&__m256i_op01) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_op00) = 0x419cd5b11c3c5654; ++ *((unsigned long *)&__m256i_result3) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_result2) = 0x2475cef801f0ffdd; ++ *((unsigned long *)&__m256i_result1) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_result0) = 0x419cd5b11c3c5654; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x22); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000001ff; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007fffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007fffff; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000017f00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00007f7f03030000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000017f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007f7f03030000; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x37); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsat_du (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvadd-xvadda-xvad.patch
Added
@@ -0,0 +1,6368 @@ +From a6d51c0d69572f800f63c3215b7de6665024104c Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:15:40 +0800 +Subject: PATCH 099/124 LoongArch: Add tests for ASX vector + xvadd/xvadda/xvaddi/xvaddwev/ xvaddwodxvsadd instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvadd.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvadda.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvaddi.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvaddwev-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvaddwev-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvaddwev-3.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvaddwod-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvaddwod-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvaddwod-3.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsadd-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsadd-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvadd.c | 725 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvadda.c | 785 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvaddi.c | 427 ++++++++++ + .../loongarch/vector/lasx/lasx-xvaddwev-1.c | 740 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvaddwev-2.c | 485 +++++++++++ + .../loongarch/vector/lasx/lasx-xvaddwev-3.c | 515 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvaddwod-1.c | 530 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvaddwod-2.c | 560 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvaddwod-3.c | 485 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsadd-1.c | 650 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsadd-2.c | 350 ++++++++ + 11 files changed, 6252 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadd.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadda.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadd.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadd.c +new file mode 100644 +index 000000000..293295723 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadd.c +@@ -0,0 +1,725 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffefefffffefe; ++ __m256i_out = __lasx_xvadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x41cfe01dde000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x41cfe01dde000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x41cfe01dde000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x41cfe01dde000000; ++ __m256i_out = __lasx_xvadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000004000000040; ++ __m256i_out = __lasx_xvadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffefffefffefffe; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000200; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op02) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7f8000007f7fffff; ++ *((unsigned long *)&__m256i_result2) = 0x7f8000007f7fffff; ++ *((unsigned long *)&__m256i_result1) = 0x7f8000007f7fffff; ++ *((unsigned long *)&__m256i_result0) = 0x7f8000007f7fffff; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff900000800; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff900000800; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_op12) = 0x00e9a80014ff0000; ++ *((unsigned long *)&__m256i_op11) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_op10) = 0x00e9a80014ff0000; ++ *((unsigned long *)&__m256i_result3) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_result2) = 0x00e9a80014ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_result0) = 0x00e9a80014ff0000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000956a; ++ *((unsigned long *)&__m256i_op02) = 0x000000004efffe00; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000956a; ++ *((unsigned long *)&__m256i_op00) = 0x000000004efffe00; ++ *((unsigned long *)&__m256i_op13) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xb500000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xb500000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x007fffffffff9569; ++ *((unsigned long *)&__m256i_result2) = 0xb50000004efffe00; ++ *((unsigned long *)&__m256i_result1) = 0x007fffffffff9569; ++ *((unsigned long *)&__m256i_result0) = 0xb50000004efffe00; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op11) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff01; ++ __m256i_out = __lasx_xvadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000ffff8000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x06f880008000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800080008000b8f1; ++ *((unsigned long *)&__m256i_op13) = 0x8000010180000101; ++ *((unsigned long *)&__m256i_op12) = 0xfa08800080000101; ++ *((unsigned long *)&__m256i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x800080008000480f; ++ *((unsigned long *)&__m256i_result3) = 0x0001010000010100; ++ *((unsigned long *)&__m256i_result2) = 0x0101000000010100; ++ *((unsigned long *)&__m256i_result1) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000000010100; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00ffffffffff605a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ffffffffff605a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ffffffffff605a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ffffffffff605a; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_op02) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op01) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_op00) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_result2) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_result1) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_result0) = 0x55555555aaaaaaac; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op12) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op11) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_result3) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result2) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_result1) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000089; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000014402080144; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_op12) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_op10) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800000008; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op02) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op01) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op00) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result2) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result1) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result0) = 0x0202010202020102; ++ __m256i_out = __lasx_xvadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op01) = 0x3fff3fff3fff4000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000403f3fff; ++ *((unsigned long *)&__m256i_op13) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op12) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op11) = 0x3fff3fff3fff4000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000403f3fff; ++ *((unsigned long *)&__m256i_result3) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m256i_result2) = 0x000000007ffe7ffe; ++ *((unsigned long *)&__m256i_result1) = 0x7ffe7ffe7ffe8000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000807e7ffe; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op02) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op01) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op00) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op13) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op12) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op11) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op10) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_result3) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result2) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result1) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result0) = 0xc2c2c2c2c2c2c2c2; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op12) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op11) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op10) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result3) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result2) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result1) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result0) = 0x7f807f007f7f817f; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op02) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op01) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op00) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op13) = 0x000000006040190d; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000006040190d; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000860601934; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_result1) = 0x0000000860601934; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800200028; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d0005; ++ __m256i_out = __lasx_xvadd_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op02) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op01) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op00) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000c0000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000040000000; ++ *((unsigned long *)&__m256i_result3) = 0x0020001f001f001e; ++ *((unsigned long *)&__m256i_result2) = 0x001f001fc01f001f; ++ *((unsigned long *)&__m256i_result1) = 0x0020001f001f001e; ++ *((unsigned long *)&__m256i_result0) = 0x001f001f401f001f; ++ __m256i_out = __lasx_xvadd_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7ffeffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7ffeffffffff; ++ __m256i_out = __lasx_xvadd_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x800000ff800000ff; ++ __m256i_out = __lasx_xvadd_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op12) = 0x0000010000080040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op10) = 0x0000010000080040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result2) = 0x0000010000080040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000080040; ++ __m256i_out = __lasx_xvadd_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffeffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffeffff0000; ++ __m256i_out = __lasx_xvadd_q (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadda.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadda.c +new file mode 100644 +index 000000000..d6b57d1cd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvadda.c +@@ -0,0 +1,785 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0101000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0101008000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0101008000000080; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000402000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000402000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000402000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000402000000; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffeffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100010102; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000102; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000102; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xefefefefefefefef; ++ *((unsigned long *)&__m256i_op02) = 0xefefefefefefefef; ++ *((unsigned long *)&__m256i_op01) = 0xefefefefefefef6e; ++ *((unsigned long *)&__m256i_op00) = 0xeeeeeeeeeeeeeeee; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x1010101010101012; ++ *((unsigned long *)&__m256i_result2) = 0x1010101010101012; ++ *((unsigned long *)&__m256i_result1) = 0x1010101010101093; ++ *((unsigned long *)&__m256i_result0) = 0x1111111111111113; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op13) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0110000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0110000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0110000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0110000000000080; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1000000000000000; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xce7ffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xce7ffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x327f010101010102; ++ *((unsigned long *)&__m256i_result2) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x327f010101010102; ++ *((unsigned long *)&__m256i_result0) = 0x6300000000000000; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff5556aaaa; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff5556aaaa; ++ *((unsigned long *)&__m256i_op13) = 0x0006ffff0004ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0006ffff0004ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0006ffff0004ffff; ++ *((unsigned long *)&__m256i_result2) = 0x00020000aaa95556; ++ *((unsigned long *)&__m256i_result1) = 0x0006ffff0004ffff; ++ *((unsigned long *)&__m256i_result0) = 0x00020000aaa95556; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xdb801b6d0962003f; ++ *((unsigned long *)&__m256i_op12) = 0xdb8a3109fe0f0024; ++ *((unsigned long *)&__m256i_op11) = 0x9a7f997fff01ffff; ++ *((unsigned long *)&__m256i_op10) = 0xbe632a4f1c3c5653; ++ *((unsigned long *)&__m256i_result3) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_result2) = 0x2475cef801f0ffdd; ++ *((unsigned long *)&__m256i_result1) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_result0) = 0x419cd5b11c3c5654; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x017e01fe01fe01fe; ++ *((unsigned long *)&__m256i_op02) = 0x0586060601fe0202; ++ *((unsigned long *)&__m256i_op01) = 0x017e01fe01fe0000; ++ *((unsigned long *)&__m256i_op00) = 0x0586060601fe0004; ++ *((unsigned long *)&__m256i_op13) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op12) = 0x0010001000100001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op10) = 0x0010001000100001; ++ *((unsigned long *)&__m256i_result3) = 0x017f01fe01ff01fe; ++ *((unsigned long *)&__m256i_result2) = 0x05960616020e0203; ++ *((unsigned long *)&__m256i_result1) = 0x017f01fe01ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x05960616020e0005; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010146; ++ *((unsigned long *)&__m256i_result2) = 0x01010101010e0106; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010146; ++ *((unsigned long *)&__m256i_result0) = 0x01010101010e0106; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op02) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op01) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op00) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result2) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result1) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result0) = 0x0010000000100000; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffb79fb74; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffb79fb74; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_result3) = 0x000000010486048c; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000006; ++ *((unsigned long *)&__m256i_result1) = 0x000000010486048c; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000006; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000020000; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x00010001000c4411; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100044411; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000002000000018; ++ *((unsigned long *)&__m256i_op02) = 0x0000002000000019; ++ *((unsigned long *)&__m256i_op01) = 0x000000200000001e; ++ *((unsigned long *)&__m256i_op00) = 0x0000002000000019; ++ *((unsigned long *)&__m256i_op13) = 0x223d76f09f3881ff; ++ *((unsigned long *)&__m256i_op12) = 0x3870ca8d013e76a0; ++ *((unsigned long *)&__m256i_op11) = 0x223d76f09f37e357; ++ *((unsigned long *)&__m256i_op10) = 0x43ec0a1b2aba7ed0; ++ *((unsigned long *)&__m256i_result3) = 0x223d771060c77e19; ++ *((unsigned long *)&__m256i_result2) = 0x3870caad013e76b9; ++ *((unsigned long *)&__m256i_result1) = 0x223d771060c81cc7; ++ *((unsigned long *)&__m256i_result0) = 0x43ec0a3b2aba7ee9; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op02) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_op01) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op00) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2535253514141414; ++ *((unsigned long *)&__m256i_result2) = 0x2535253500002535; ++ *((unsigned long *)&__m256i_result1) = 0x2535253514141414; ++ *((unsigned long *)&__m256i_result0) = 0x2535253500002535; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op02) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_op01) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op00) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_result2) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_result1) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_result0) = 0x0010000f0000000f; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000504f00002361; ++ *((unsigned long *)&__m256i_op02) = 0xffff8f81000040e4; ++ *((unsigned long *)&__m256i_op01) = 0x0000504f00002361; ++ *((unsigned long *)&__m256i_op00) = 0xffff8f81000040e4; ++ *((unsigned long *)&__m256i_op13) = 0x000007ff000007ff; ++ *((unsigned long *)&__m256i_op12) = 0x000007ff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x000007ff000007ff; ++ *((unsigned long *)&__m256i_op10) = 0x000007ff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000584e00002b60; ++ *((unsigned long *)&__m256i_result2) = 0x0000787dffffbf1c; ++ *((unsigned long *)&__m256i_result1) = 0x0000584e00002b60; ++ *((unsigned long *)&__m256i_result0) = 0x0000787dffffbf1c; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010200000000; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op12) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x7fef010000010100; ++ *((unsigned long *)&__m256i_result2) = 0x7fef010000010100; ++ *((unsigned long *)&__m256i_result1) = 0x7fef010000010100; ++ *((unsigned long *)&__m256i_result0) = 0x7fef010000010100; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000001fe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x40b2bf4d30313031; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fffa2bea2be; ++ *((unsigned long *)&__m256i_op01) = 0x40b2bf4d30313031; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fffa2bea2be; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x40b240b330313031; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff5d425d42; ++ *((unsigned long *)&__m256i_result1) = 0x40b240b330313031; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff5d425d42; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000100040; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000100080; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff896099cbdbfff1; ++ *((unsigned long *)&__m256i_op02) = 0xc987ffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xff896099cbdbfff1; ++ *((unsigned long *)&__m256i_op00) = 0xc987ffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00769f673424000f; ++ *((unsigned long *)&__m256i_result2) = 0x3678000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x00769f673424000f; ++ *((unsigned long *)&__m256i_result0) = 0x3678000100000001; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadda_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000500000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000700000032; ++ *((unsigned long *)&__m256i_result1) = 0x0000000500000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000700000032; ++ __m256i_out = __lasx_xvadda_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op02) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op01) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op00) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op13) = 0x00003feec0108022; ++ *((unsigned long *)&__m256i_op12) = 0x00003fe9c015802c; ++ *((unsigned long *)&__m256i_op11) = 0x00003feec0108022; ++ *((unsigned long *)&__m256i_op10) = 0x00003fe9c015802c; ++ *((unsigned long *)&__m256i_result3) = 0x00007f124010c022; ++ *((unsigned long *)&__m256i_result2) = 0x00007f174015c02c; ++ *((unsigned long *)&__m256i_result1) = 0x00007f124010c022; ++ *((unsigned long *)&__m256i_result0) = 0x00007f174015c02c; ++ __m256i_out = __lasx_xvadda_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x05ea05ea05ea05ec; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x05ea05ea05ea05ec; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000020202020202; ++ *((unsigned long *)&__m256i_result2) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000020202020202; ++ *((unsigned long *)&__m256i_result0) = 0x0101000000010000; ++ __m256i_out = __lasx_xvadda_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddi.c +new file mode 100644 +index 000000000..054bf6e55 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddi.c +@@ -0,0 +1,427 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x44bb2cd3a35c2fd0; ++ *((unsigned long *)&__m256i_op00) = 0xca355ba46a95e31c; ++ *((unsigned long *)&__m256i_result3) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_result2) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_result1) = 0x61d849f0c0794ced; ++ *((unsigned long *)&__m256i_result0) = 0xe75278c187b20039; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffbf7f7fff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe651bfff; ++ *((unsigned long *)&__m256i_result3) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_result2) = 0x1d1d1d1ddd9d9d1d; ++ *((unsigned long *)&__m256i_result1) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_result0) = 0x1d1d1d1d046fdd1d; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1515151515151515; ++ *((unsigned long *)&__m256i_result2) = 0x1515151515151515; ++ *((unsigned long *)&__m256i_result1) = 0x1515151515151515; ++ *((unsigned long *)&__m256i_result0) = 0x1515151515151515; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1818181818181818; ++ *((unsigned long *)&__m256i_result2) = 0x1818181818181818; ++ *((unsigned long *)&__m256i_result1) = 0x1818181818181818; ++ *((unsigned long *)&__m256i_result0) = 0x1818181818181818; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00007fff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00007fff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_result2) = 0x0202810102020202; ++ *((unsigned long *)&__m256i_result1) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_result0) = 0x0202810102020202; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_result2) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_result1) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_result0) = 0x0909090909090909; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ffce20; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ffce20; ++ *((unsigned long *)&__m256i_result3) = 0x1514151415141514; ++ *((unsigned long *)&__m256i_result2) = 0x151415141514e335; ++ *((unsigned long *)&__m256i_result1) = 0x1514151415141514; ++ *((unsigned long *)&__m256i_result0) = 0x151415141514e335; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0606060606060606; ++ *((unsigned long *)&__m256i_result2) = 0x0606060606060606; ++ *((unsigned long *)&__m256i_result1) = 0x0606060606060606; ++ *((unsigned long *)&__m256i_result0) = 0x0606060606060606; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1212121212121212; ++ *((unsigned long *)&__m256i_result2) = 0x1212121212121212; ++ *((unsigned long *)&__m256i_result1) = 0x1212121212121212; ++ *((unsigned long *)&__m256i_result0) = 0x1212121212121212; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_op02) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_op01) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_op00) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_result3) = 0x1a1a1a2c1a1a1a2c; ++ *((unsigned long *)&__m256i_result2) = 0x1a1a1a2c1a1a1a2c; ++ *((unsigned long *)&__m256i_result1) = 0x1a1a1a2c1a1a1a2c; ++ *((unsigned long *)&__m256i_result0) = 0x1a1a1a2c1a1a1a2c; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x1d1d1d1e1d1d1d1e; ++ *((unsigned long *)&__m256i_result2) = 0x1d1d1d1e1d1d1d1e; ++ *((unsigned long *)&__m256i_result1) = 0x1d1d1d1e1d1d1d1e; ++ *((unsigned long *)&__m256i_result0) = 0x1d1d1d1e1d1d1d1e; ++ __m256i_out = __lasx_xvaddi_bu (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result2) = 0x5982000200020002; ++ *((unsigned long *)&__m256i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result0) = 0x5982000200020002; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result3) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result2) = 0x001f001f02c442af; ++ *((unsigned long *)&__m256i_result1) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result0) = 0x001f001f02c442af; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100010; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x807e80fd80fe80fd; ++ *((unsigned long *)&__m256i_op02) = 0x80938013800d8002; ++ *((unsigned long *)&__m256i_op01) = 0x807e80fd80fe0000; ++ *((unsigned long *)&__m256i_op00) = 0x80938013800d0005; ++ *((unsigned long *)&__m256i_result3) = 0x8091811081118110; ++ *((unsigned long *)&__m256i_result2) = 0x80a6802680208015; ++ *((unsigned long *)&__m256i_result1) = 0x8091811081110013; ++ *((unsigned long *)&__m256i_result0) = 0x80a6802680200018; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000003f00390035; ++ *((unsigned long *)&__m256i_op02) = 0x8015003f0006001f; ++ *((unsigned long *)&__m256i_op01) = 0x0000003f00390035; ++ *((unsigned long *)&__m256i_op00) = 0x8015003f0006001f; ++ *((unsigned long *)&__m256i_result3) = 0x000b004a00440040; ++ *((unsigned long *)&__m256i_result2) = 0x8020004a0011002a; ++ *((unsigned long *)&__m256i_result1) = 0x000b004a00440040; ++ *((unsigned long *)&__m256i_result0) = 0x8020004a0011002a; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0016001600160016; ++ *((unsigned long *)&__m256i_result2) = 0x0016001600160016; ++ *((unsigned long *)&__m256i_result1) = 0x0016001600160016; ++ *((unsigned long *)&__m256i_result0) = 0x0016001600160016; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_op02) = 0xa1a1a1a15e5e5e5e; ++ *((unsigned long *)&__m256i_op01) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_op00) = 0xa1a1a1a15e5e5e5e; ++ *((unsigned long *)&__m256i_result3) = 0xa1bfa1bfa1bfa1bf; ++ *((unsigned long *)&__m256i_result2) = 0xa1bfa1bf5e7c5e7c; ++ *((unsigned long *)&__m256i_result1) = 0xa1bfa1bfa1bfa1bf; ++ *((unsigned long *)&__m256i_result0) = 0xa1bfa1bf5e7c5e7c; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_result3) = 0x001a001a001a009a; ++ *((unsigned long *)&__m256i_result2) = 0x001a001a002a009a; ++ *((unsigned long *)&__m256i_result1) = 0x001a001a001a009a; ++ *((unsigned long *)&__m256i_result0) = 0x001a001a002a009a; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x001c001c001c001c; ++ *((unsigned long *)&__m256i_result2) = 0x001c001c001c001c; ++ *((unsigned long *)&__m256i_result1) = 0x001c001c001c001c; ++ *((unsigned long *)&__m256i_result0) = 0x001c001c001d001d; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_op02) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_op01) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_op00) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_result3) = 0x721e001e721e001e; ++ *((unsigned long *)&__m256i_result2) = 0x721e001e721e001e; ++ *((unsigned long *)&__m256i_result1) = 0x721e001e721e001e; ++ *((unsigned long *)&__m256i_result0) = 0x721e001e721e001e; ++ __m256i_out = __lasx_xvaddi_hu (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result2) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result1) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result0) = 0x0000001900000019; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000600000006; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result2) = 0x0000001a0000001a; ++ *((unsigned long *)&__m256i_result1) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result0) = 0x0000001a0000001a; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result2) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result1) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result0) = 0x0000001900000019; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000001d0000001d; ++ *((unsigned long *)&__m256i_result2) = 0x0000001d0000001d; ++ *((unsigned long *)&__m256i_result1) = 0x0000001d0000001d; ++ *((unsigned long *)&__m256i_result0) = 0x0000001d0000001d; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000600000006; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000001fffd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000001fffd; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000700020004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000700020004; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800000008; ++ __m256i_out = __lasx_xvaddi_wu (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000019410000e69a; ++ *((unsigned long *)&__m256i_op02) = 0xf259905a0c126604; ++ *((unsigned long *)&__m256i_op01) = 0x0000883a00000f20; ++ *((unsigned long *)&__m256i_op00) = 0x6d3c2d3aa1c82947; ++ *((unsigned long *)&__m256i_result3) = 0x000019410000e6aa; ++ *((unsigned long *)&__m256i_result2) = 0xf259905a0c126614; ++ *((unsigned long *)&__m256i_result1) = 0x0000883a00000f30; ++ *((unsigned long *)&__m256i_result0) = 0x6d3c2d3aa1c82957; ++ __m256i_out = __lasx_xvaddi_du (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000000d; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000d; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000000d; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000d; ++ __m256i_out = __lasx_xvaddi_du (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0xfff0fff0fff0fff0; ++ *((unsigned long *)&__m256i_op01) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0xfff0fff0fff0fff0; ++ *((unsigned long *)&__m256i_result3) = 0xfff0fff0ff01ff14; ++ *((unsigned long *)&__m256i_result2) = 0xfff0fff0fff10003; ++ *((unsigned long *)&__m256i_result1) = 0xfff0fff0ff01ff14; ++ *((unsigned long *)&__m256i_result0) = 0xfff0fff0fff10003; ++ __m256i_out = __lasx_xvaddi_du (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op02) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_op01) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op00) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_result3) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_result2) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_result1) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_result0) = 0xffff47b4ffff5879; ++ __m256i_out = __lasx_xvaddi_du (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvaddi_du (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_result2) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_result1) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_result0) = 0x0fffffff10000006; ++ __m256i_out = __lasx_xvaddi_du (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-1.c +new file mode 100644 +index 000000000..70f3bf783 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-1.c +@@ -0,0 +1,740 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op02) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op01) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op00) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffeffffff88; ++ *((unsigned long *)&__m256i_op12) = 0x61e0000000000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffeffffff88; ++ *((unsigned long *)&__m256i_op10) = 0x61e0000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0010ffc80010ff52; ++ *((unsigned long *)&__m256i_result2) = 0xfff1ffca0011ffcb; ++ *((unsigned long *)&__m256i_result1) = 0x0010ffc80010ff52; ++ *((unsigned long *)&__m256i_result0) = 0xfff1ffca0011ffcb; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfffffe90ffffff80; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffe90ffffff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffff90ffffff80; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000005; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffefffefffefffe; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000023; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x01c601c6fe3afe3a; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x01c601c6fe3afe3a; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000011; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op02) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op01) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op00) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x007d003e007d003e; ++ *((unsigned long *)&__m256i_result2) = 0x007d003effa80010; ++ *((unsigned long *)&__m256i_result1) = 0x007d003e007d003e; ++ *((unsigned long *)&__m256i_result0) = 0x007d003effa80010; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ca0000fff80000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00ca0000fff80000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256i_op02) = 0x5464fbfc416b9f71; ++ *((unsigned long *)&__m256i_op01) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256i_op00) = 0x0d8264202b8ea3f0; ++ *((unsigned long *)&__m256i_op13) = 0x80c72fcd40fb3bc0; ++ *((unsigned long *)&__m256i_op12) = 0x84bd087966d4ace0; ++ *((unsigned long *)&__m256i_op11) = 0x26aa68b274dc1322; ++ *((unsigned long *)&__m256i_op10) = 0xe072db2bb9d4cd40; ++ *((unsigned long *)&__m256i_result3) = 0xffffcd42ffffecc0; ++ *((unsigned long *)&__m256i_result2) = 0x00000475ffff4c51; ++ *((unsigned long *)&__m256i_result1) = 0x0000740dffffad17; ++ *((unsigned long *)&__m256i_result0) = 0x00003f4bffff7130; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256i_op02) = 0x0000468600007f79; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000f3280000dfff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffff80; ++ *((unsigned long *)&__m256i_result2) = 0x0000468600008078; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffff328ffffe021; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op02) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op01) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op00) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op13) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op12) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op11) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op10) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_result3) = 0x0000399400003994; ++ *((unsigned long *)&__m256i_result2) = 0x0000399400003994; ++ *((unsigned long *)&__m256i_result1) = 0x0000399400003994; ++ *((unsigned long *)&__m256i_result0) = 0x0000399400003994; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_op12) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_op11) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_op10) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_result3) = 0x0000616100004f61; ++ *((unsigned long *)&__m256i_result2) = 0x0000616100004f61; ++ *((unsigned long *)&__m256i_result1) = 0x0000616100004f61; ++ *((unsigned long *)&__m256i_result0) = 0x0000616100004f61; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op12) = 0x000b8f81b8c840e4; ++ *((unsigned long *)&__m256i_op11) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op10) = 0x000b8f81b8c840e4; ++ *((unsigned long *)&__m256i_result3) = 0x0000504f00002361; ++ *((unsigned long *)&__m256i_result2) = 0xffff8f81000040e4; ++ *((unsigned long *)&__m256i_result1) = 0x0000504f00002361; ++ *((unsigned long *)&__m256i_result0) = 0xffff8f81000040e4; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000012; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op13) = 0x40b240b330313031; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff5d425d42; ++ *((unsigned long *)&__m256i_op11) = 0x40b240b330313031; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff5d425d42; ++ *((unsigned long *)&__m256i_result3) = 0x000040b200002fd4; ++ *((unsigned long *)&__m256i_result2) = 0x00007fff0000739c; ++ *((unsigned long *)&__m256i_result1) = 0x000040b200002fd4; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff0000739c; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op02) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_op01) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op00) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_op13) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op12) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_op11) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op10) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_result3) = 0x00007fde00007fd4; ++ *((unsigned long *)&__m256i_result2) = 0x00007fe000007fe0; ++ *((unsigned long *)&__m256i_result1) = 0x00007fde00007fd4; ++ *((unsigned long *)&__m256i_result0) = 0x00007fe000007fe0; ++ __m256i_out = __lasx_xvaddwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002e2100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x00000000012e2110; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op02) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op01) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op00) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000583800; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000100000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000583800; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000100000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op02) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op01) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op00) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007bbbbbbb; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007bbbbbbb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_result2) = 0x0000000073333333; ++ *((unsigned long *)&__m256i_result1) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_result0) = 0x0000000073333333; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007f807f007e8080; ++ *((unsigned long *)&__m256i_op02) = 0x007f807f007e806f; ++ *((unsigned long *)&__m256i_op01) = 0x007f807f007e8080; ++ *((unsigned long *)&__m256i_op00) = 0x007f807f007e806f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_result3) = 0x00000000007e8080; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007e8092; ++ *((unsigned long *)&__m256i_result1) = 0x00000000007e8080; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007e8092; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000062d4; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000006338; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0010000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0010000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0010000100000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff80000000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfe01fe01fc01fc01; ++ *((unsigned long *)&__m256i_op12) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op11) = 0xfe01fe01fc01fc01; ++ *((unsigned long *)&__m256i_op10) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_result2) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_result0) = 0x000000003fc03bbc; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x1b9763952fc4c101; ++ *((unsigned long *)&__m256i_op12) = 0xe37affb42fc05f69; ++ *((unsigned long *)&__m256i_op11) = 0x18b988e64facb558; ++ *((unsigned long *)&__m256i_op10) = 0xe5fb66c81da8e5bb; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xe37affb42fc05f69; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x65fb66c81da8e5ba; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x1010101010101012; ++ *((unsigned long *)&__m256i_op12) = 0x1010101010101012; ++ *((unsigned long *)&__m256i_op11) = 0x1010101010101093; ++ *((unsigned long *)&__m256i_op10) = 0x1111111111111113; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1010101110101011; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1111111211111112; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x5980000000000000; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffefe00000000; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000002800000010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000002800000010; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff0127000c0010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff012700040010; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xc0008000c0008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xc0008000c0008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xc0008000c0008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xc0008000c0008000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x8001000180010000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x8001000180010000; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op13) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff800200000002; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff800200000002; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000020000000200; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffe97c020010001; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000001e001e001e0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000001e001e001e0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-2.c +new file mode 100644 +index 000000000..22528a14f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-2.c +@@ -0,0 +1,485 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0010000000000000; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffc0003fffa0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x01fb010201f900ff; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000005554; ++ *((unsigned long *)&__m256i_op12) = 0xaaaa0000aaacfffe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000005554; ++ *((unsigned long *)&__m256i_op10) = 0xaaaa0000aaacfffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000054; ++ *((unsigned long *)&__m256i_result2) = 0x00aa000000ac00fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000054; ++ *((unsigned long *)&__m256i_result0) = 0x00aa000000ac00fe; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x017f01fe01ff01fe; ++ *((unsigned long *)&__m256i_op02) = 0x05960616020e0203; ++ *((unsigned long *)&__m256i_op01) = 0x017f01fe01ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x05960616020e0005; ++ *((unsigned long *)&__m256i_op13) = 0x017f01fe01ff01fe; ++ *((unsigned long *)&__m256i_op12) = 0x05960616020e0203; ++ *((unsigned long *)&__m256i_op11) = 0x017f01fe01ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x05960616020e0005; ++ *((unsigned long *)&__m256i_result3) = 0x00fe01fc01fe01fc; ++ *((unsigned long *)&__m256i_result2) = 0x012c002c001c0006; ++ *((unsigned long *)&__m256i_result1) = 0x00fe01fc01fe0000; ++ *((unsigned long *)&__m256i_result0) = 0x012c002c001c000a; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op02) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_op01) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op00) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_op13) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op12) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op11) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op10) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_result3) = 0x0007000000fb00ef; ++ *((unsigned long *)&__m256i_result2) = 0x00ea005600f90090; ++ *((unsigned long *)&__m256i_result1) = 0x0007000000fb00ef; ++ *((unsigned long *)&__m256i_result0) = 0x00ea005600f90090; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffc03b1fc5e050; ++ *((unsigned long *)&__m256i_op02) = 0x6a9e3fa2603a2000; ++ *((unsigned long *)&__m256i_op01) = 0xffffc03b1fc5e050; ++ *((unsigned long *)&__m256i_op00) = 0x6a9e3fa2603a2000; ++ *((unsigned long *)&__m256i_op13) = 0xffffc03fffffffc0; ++ *((unsigned long *)&__m256i_op12) = 0xffffc00000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffc03fffffffc0; ++ *((unsigned long *)&__m256i_op10) = 0xffffc00000000000; ++ *((unsigned long *)&__m256i_result3) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_result2) = 0x019d00a2003a0000; ++ *((unsigned long *)&__m256i_result1) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_result0) = 0x019d00a2003a0000; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op02) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op01) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op00) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00e30064001a008f; ++ *((unsigned long *)&__m256i_result2) = 0x00e3006300e30063; ++ *((unsigned long *)&__m256i_result1) = 0x00e30064001a008f; ++ *((unsigned long *)&__m256i_result0) = 0x00e3006300e30063; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000013; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op12) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_op11) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op10) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_result3) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_result2) = 0x000000a400ff004f; ++ *((unsigned long *)&__m256i_result1) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_result0) = 0x000000a400ff004f; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0002ffff00020002; ++ *((unsigned long *)&__m256i_op02) = 0x04f504f104f504f5; ++ *((unsigned long *)&__m256i_op01) = 0x0002ffff00020002; ++ *((unsigned long *)&__m256i_op00) = 0x04f504f104f504f5; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000200ff00020002; ++ *((unsigned long *)&__m256i_result2) = 0x00f500f100f500f5; ++ *((unsigned long *)&__m256i_result1) = 0x000200ff00020002; ++ *((unsigned long *)&__m256i_result0) = 0x00f500f100f500f5; ++ __m256i_out = __lasx_xvaddwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000019410000e69a; ++ *((unsigned long *)&__m256i_op02) = 0xf259905a0c126604; ++ *((unsigned long *)&__m256i_op01) = 0x0000883a00000f20; ++ *((unsigned long *)&__m256i_op00) = 0x6d3c2d3aa1c82947; ++ *((unsigned long *)&__m256i_op13) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256i_op12) = 0xc5c085372cfabfba; ++ *((unsigned long *)&__m256i_op11) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256i_op10) = 0x0658f2dc0eb21e3c; ++ *((unsigned long *)&__m256i_result3) = 0x0000b6b60001979a; ++ *((unsigned long *)&__m256i_result2) = 0x00011591000125be; ++ *((unsigned long *)&__m256i_result1) = 0x000093950000a915; ++ *((unsigned long *)&__m256i_result0) = 0x0001201600004783; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffff6ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffff6ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8011ffee804c004c; ++ *((unsigned long *)&__m256i_op02) = 0x00faff0500c3ff3c; ++ *((unsigned long *)&__m256i_op01) = 0x80f900f980780078; ++ *((unsigned long *)&__m256i_op00) = 0x0057ffa800ceff31; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_op12) = 0xff000000ff000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m256i_op10) = 0xff000000ff000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffee0000ff4c; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff050000ff3c; ++ *((unsigned long *)&__m256i_result1) = 0x0000fff90000ff78; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffa80000ff31; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffc7f7f; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffc000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fffc7f7f; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffc000; ++ *((unsigned long *)&__m256i_op13) = 0x8001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x8001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000b0b100015d1e; ++ *((unsigned long *)&__m256i_result2) = 0x0001fffe0001bfff; ++ *((unsigned long *)&__m256i_result1) = 0x0000b0b100015d1e; ++ *((unsigned long *)&__m256i_result0) = 0x0001fffe0001bfff; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000fe200000fe1f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fe200000fe1f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffc0ffc1; ++ *((unsigned long *)&__m256i_op02) = 0x003f00000000003f; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffc0ffc1; ++ *((unsigned long *)&__m256i_op00) = 0x003f00000000003f; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001fffe0001ffc0; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0001003e; ++ *((unsigned long *)&__m256i_result1) = 0x0001fffe0001ffc0; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0001003e; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020010101610000; ++ *((unsigned long *)&__m256i_op02) = 0x0061200000610000; ++ *((unsigned long *)&__m256i_op01) = 0x0020010101610000; ++ *((unsigned long *)&__m256i_op00) = 0x0061200000610000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000101000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x00011fff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000101000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x00011fff0000ffff; ++ __m256i_out = __lasx_xvaddwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvaddwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000013ffffffec; ++ *((unsigned long *)&__m256i_op12) = 0x00000013ffffebd8; ++ *((unsigned long *)&__m256i_op11) = 0x00000013ffffffec; ++ *((unsigned long *)&__m256i_op10) = 0x00000013ffffebd8; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffec; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffebd8; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffec; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffebd8; ++ __m256i_out = __lasx_xvaddwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000c0007; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000c0007; ++ *((unsigned long *)&__m256i_op13) = 0x3abb3abbbabababa; ++ *((unsigned long *)&__m256i_op12) = 0x0080000000800080; ++ *((unsigned long *)&__m256i_op11) = 0x3abb3abbbabababa; ++ *((unsigned long *)&__m256i_op10) = 0x0080000000800080; ++ *((unsigned long *)&__m256i_result3) = 0x00000000babababa; ++ *((unsigned long *)&__m256i_result2) = 0x00000000008c0087; ++ *((unsigned long *)&__m256i_result1) = 0x00000000babababa; ++ *((unsigned long *)&__m256i_result0) = 0x00000000008c0087; ++ __m256i_out = __lasx_xvaddwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvaddwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000010000000a; ++ __m256i_out = __lasx_xvaddwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8060000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8060000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x805f0000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x805f0000ffffffff; ++ __m256i_out = __lasx_xvaddwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe01fe010000fd02; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_op01) = 0xfe01fe010000fd02; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_op13) = 0xfe01fe010000fd02; ++ *((unsigned long *)&__m256i_op12) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_op11) = 0xfe01fe010000fd02; ++ *((unsigned long *)&__m256i_op10) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f807f80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f807f80; ++ __m256i_out = __lasx_xvaddwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff1cff1cff1cff1c; ++ __m256i_out = __lasx_xvaddwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-3.c +new file mode 100644 +index 000000000..38a0a53d7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwev-3.c +@@ -0,0 +1,515 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op02) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op01) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op00) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op13) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op12) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op11) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op10) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result3) = 0x0036003200360032; ++ *((unsigned long *)&__m256i_result2) = 0x0036003200360032; ++ *((unsigned long *)&__m256i_result1) = 0x0036003200360032; ++ *((unsigned long *)&__m256i_result0) = 0x0036003200360032; ++ __m256i_out = __lasx_xvaddwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000170017; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000170017; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000170017; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000170017; ++ __m256i_out = __lasx_xvaddwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000100fe000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000100fe00010001; ++ *((unsigned long *)&__m256i_result1) = 0x000100fe000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000100fe00010001; ++ __m256i_out = __lasx_xvaddwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6100000800060005; ++ *((unsigned long *)&__m256i_op02) = 0x5ee1c073b800c916; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5ff00007fff9fff3; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0209fefb08140000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000bf6e0000c916; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000030000fff3; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000b004a00440040; ++ *((unsigned long *)&__m256i_op02) = 0x8020004a0011002a; ++ *((unsigned long *)&__m256i_op01) = 0x000b004a00440040; ++ *((unsigned long *)&__m256i_op00) = 0x8020004a0011002a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000004a00000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000004a0000002a; ++ *((unsigned long *)&__m256i_result1) = 0x0000004a00000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000004a0000002a; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_op12) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_op11) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_op10) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result3) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result2) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result1) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result0) = 0x00001fff00001fff; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001a001a001a009a; ++ *((unsigned long *)&__m256i_op02) = 0x001a001a002a009a; ++ *((unsigned long *)&__m256i_op01) = 0x001a001a001a009a; ++ *((unsigned long *)&__m256i_op00) = 0x001a001a002a009a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000001a000000da; ++ *((unsigned long *)&__m256i_result2) = 0x0000001a000000da; ++ *((unsigned long *)&__m256i_result1) = 0x0000001a000000da; ++ *((unsigned long *)&__m256i_result0) = 0x0000001a000000da; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result1) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000007ffffffce; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000001fe; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000001ce; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000001fe; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000001ce; ++ __m256i_out = __lasx_xvaddwev_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff0000; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ff000000010000; ++ *((unsigned long *)&__m256i_op13) = 0x8011ffae800c000c; ++ *((unsigned long *)&__m256i_op12) = 0x00baff050083ff3c; ++ *((unsigned long *)&__m256i_op11) = 0x80b900b980380038; ++ *((unsigned long *)&__m256i_op10) = 0x0017ffa8008eff31; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff800c000c; ++ *((unsigned long *)&__m256i_result2) = 0x000000000084ff3c; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff80380038; ++ *((unsigned long *)&__m256i_result0) = 0x00000000008fff31; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000001001f001e; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000001001f001e; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff00ff; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100f000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100f000ff; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_op02) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_op01) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_op00) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffc0; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fff0ffc0; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffc0; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fff0ffc0; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff78ffc0; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000016e00; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op12) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op11) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op10) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff1cff1c; ++ __m256i_out = __lasx_xvaddwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffff1f; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffeff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffff1f; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffeff; ++ *((unsigned long *)&__m256i_op13) = 0x0010ffc80010ff52; ++ *((unsigned long *)&__m256i_op12) = 0xfff1ffca0011ffcb; ++ *((unsigned long *)&__m256i_op11) = 0x0010ffc80010ff52; ++ *((unsigned long *)&__m256i_op10) = 0xfff1ffca0011ffcb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfff1ffca0011feca; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff1ffca0011feca; ++ __m256i_out = __lasx_xvaddwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000002; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000002; ++ __m256i_out = __lasx_xvaddwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000017fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000017fff; ++ __m256i_out = __lasx_xvaddwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000004000000040; ++ __m256i_out = __lasx_xvaddwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-1.c +new file mode 100644 +index 000000000..a4dc565e9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-1.c +@@ -0,0 +1,530 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x9240000000008025; ++ *((unsigned long *)&__m256i_op02) = 0xfffff24affff8025; ++ *((unsigned long *)&__m256i_op01) = 0xb2c0000000008006; ++ *((unsigned long *)&__m256i_op00) = 0xffffb341ffff8006; ++ *((unsigned long *)&__m256i_op13) = 0x9240000000008025; ++ *((unsigned long *)&__m256i_op12) = 0xfffff24affff8025; ++ *((unsigned long *)&__m256i_op11) = 0xb2c0000000008006; ++ *((unsigned long *)&__m256i_op10) = 0xffffb341ffff8006; ++ *((unsigned long *)&__m256i_result3) = 0xff2400000000ff00; ++ *((unsigned long *)&__m256i_result2) = 0xfffeffe4fffeff00; ++ *((unsigned long *)&__m256i_result1) = 0xff6400000000ff00; ++ *((unsigned long *)&__m256i_result0) = 0xfffeff66fffeff00; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op02) = 0xff04ff00ff00ff00; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op00) = 0xff04ff00ff00ff00; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffefffefffefffe; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffe0000fffe0002; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffe0000fffe0002; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000fffeffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000fffeffff; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op02) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffc0003fffc0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffc0003fffc0; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7ffeffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7ffeffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f007bfffffffb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007f007bfffffffb; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000201220001011c; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000201220001011c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe0ffe000000001; ++ *((unsigned long *)&__m256i_op02) = 0x7fa0001fff808000; ++ *((unsigned long *)&__m256i_op01) = 0xffe0ffe000000001; ++ *((unsigned long *)&__m256i_op00) = 0x7fa0001fff808000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x007f0000ffffff80; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x007f0000ffffff80; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0004000400040004; ++ __m256i_out = __lasx_xvaddwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000001fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000001fe; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000d24; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000d24; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x4ffc3f7800000000; ++ *((unsigned long *)&__m256i_op12) = 0x3fc03f6400000000; ++ *((unsigned long *)&__m256i_op11) = 0x4ffc3f7800000000; ++ *((unsigned long *)&__m256i_op10) = 0x3fc03f6400000000; ++ *((unsigned long *)&__m256i_result3) = 0x000050fd00000101; ++ *((unsigned long *)&__m256i_result2) = 0x000040c100000101; ++ *((unsigned long *)&__m256i_result1) = 0x000050fd00000101; ++ *((unsigned long *)&__m256i_result0) = 0x000040c100000101; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007fff; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000006d; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000400008; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000006d; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000400008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000800080000000; ++ *((unsigned long *)&__m256i_op01) = 0xc9d8080067f50020; ++ *((unsigned long *)&__m256i_op00) = 0xc70000020000c000; ++ *((unsigned long *)&__m256i_op13) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffe06df0d7; ++ *((unsigned long *)&__m256i_op11) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffbe8b470f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007ffffffff7ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x49d8080067f4f81f; ++ __m256i_out = __lasx_xvaddwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvaddwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff605a; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff605a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffebeb8; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffebeb8; ++ __m256i_out = __lasx_xvaddwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_op12) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_op11) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_op10) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1111111111111111; ++ __m256i_out = __lasx_xvaddwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffeffffffdd; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvaddwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d6d6d; ++ __m256i_out = __lasx_xvaddwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-2.c +new file mode 100644 +index 000000000..a2fbe9ed0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-2.c +@@ -0,0 +1,560 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe00007f000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_result1) = 0x017e00ff017e00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff017e01fe; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op02) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op01) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op00) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00b7003600120000; ++ *((unsigned long *)&__m256i_result2) = 0x00b7006200fc0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00b7004100190004; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_op01) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_op13) = 0x00000000008e7c00; ++ *((unsigned long *)&__m256i_op12) = 0x0000000067751500; ++ *((unsigned long *)&__m256i_op11) = 0x00000000008e7c00; ++ *((unsigned long *)&__m256i_op10) = 0x0000000067751500; ++ *((unsigned long *)&__m256i_result3) = 0x00000000007a00f8; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff01640092; ++ *((unsigned long *)&__m256i_result1) = 0x00000000007a00f8; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff01640092; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff000000ff0000; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00ff00ff; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff008000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff008000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00ff008000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff008000000000; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_op02) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_op00) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff008000ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff008000ff0000; ++ __m256i_out = __lasx_xvaddwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000804000004141; ++ *((unsigned long *)&__m256i_op01) = 0x00017fff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x00007fff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op12) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op11) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op10) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000004444; ++ *((unsigned long *)&__m256i_result2) = 0x00007bbb0000f777; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000004444; ++ *((unsigned long *)&__m256i_result0) = 0x00007bbb0000f777; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4010000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x3e6ce7d9cb7afb62; ++ *((unsigned long *)&__m256i_op01) = 0x4010000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x3e6ce7d9cb7afb62; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003e6c0000cb7a; ++ *((unsigned long *)&__m256i_result1) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003e6c0000cb7a; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3aadec4f6c7975b1; ++ *((unsigned long *)&__m256i_op02) = 0x3abac5447fffca89; ++ *((unsigned long *)&__m256i_op01) = 0x3aadec4f6c7975b1; ++ *((unsigned long *)&__m256i_op00) = 0x3abac5447fffca89; ++ *((unsigned long *)&__m256i_op13) = 0x3aadec4f6c7975b1; ++ *((unsigned long *)&__m256i_op12) = 0x3abac5447fffca89; ++ *((unsigned long *)&__m256i_op11) = 0x3aadec4f6c7975b1; ++ *((unsigned long *)&__m256i_op10) = 0x3abac5447fffca89; ++ *((unsigned long *)&__m256i_result3) = 0x0000755a0000d8f2; ++ *((unsigned long *)&__m256i_result2) = 0x000075740000fffe; ++ *((unsigned long *)&__m256i_result1) = 0x0000755a0000d8f2; ++ *((unsigned long *)&__m256i_result0) = 0x000075740000fffe; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op02) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op00) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffee00ba; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffee00ba; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffee; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffee; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9ffffd8020010001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff9fffffff9; ++ *((unsigned long *)&__m256i_op11) = 0x9ffffd8020010001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff9fffffff9; ++ *((unsigned long *)&__m256i_result3) = 0x00009fff00002001; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x00009fff00002001; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvaddwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000900000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000900000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000001a; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000001a; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100010000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100010000; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_op01) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00153f1594ea02ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffff0100; ++ *((unsigned long *)&__m256i_op10) = 0xff15c1ea95ea02ff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000153f15; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff15c1ea; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100fe04ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100fe04ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff00ff; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00f9f9f900000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00f9f9f900000002; ++ *((unsigned long *)&__m256i_op13) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op12) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op11) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op10) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result3) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_result2) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_result1) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_result0) = 0x00000000faf3f3f2; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000029170; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000029170; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_op02) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_op01) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_op00) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xc3f0c3f0c3f0c3f0; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op02) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op00) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op13) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_op12) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_op11) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_op10) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0xe6e8e6e8e6e8d719; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0xe6e8e6e8e6e8d719; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000003fffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000003fffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-3.c +new file mode 100644 +index 000000000..8c98fc4be +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvaddwod-3.c +@@ -0,0 +1,485 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000033e87ef1; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002e2100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000033007e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000021; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op12) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op11) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op10) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result3) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_result2) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_result1) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_result0) = 0x0020002000400040; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x007fc0083fc7c007; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x007fc0083fc7c007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffc0003fffc0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffc0003fffc0; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffb8579f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffb8579f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff00bb; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff0057; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff00bb; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff0057; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00ff00ff; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000005060503; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000073737; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000050007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000039; ++ __m256i_out = __lasx_xvaddwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256i_op02) = 0x0000468600007f79; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000f3280000dfff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000007070707; ++ *((unsigned long *)&__m256i_op12) = 0x0102040000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000020100; ++ *((unsigned long *)&__m256i_op10) = 0x0703020000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000707; ++ *((unsigned long *)&__m256i_result2) = 0x0000010200000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000070300000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00007fffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00007fffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff800000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op02) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op01) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op00) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op13) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op12) = 0x000100640000ff92; ++ *((unsigned long *)&__m256i_op11) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op10) = 0x000100640000ff92; ++ *((unsigned long *)&__m256i_result3) = 0x00007c0100007c01; ++ *((unsigned long *)&__m256i_result2) = 0x00007c0100007c00; ++ *((unsigned long *)&__m256i_result1) = 0x00007c0100007c01; ++ *((unsigned long *)&__m256i_result0) = 0x00007c0100007c00; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffe0000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000048; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000007d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000048; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000007d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800000010; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000fffe00009fff; ++ *((unsigned long *)&__m256i_result2) = 0x0000fffe00002001; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffe00009fff; ++ *((unsigned long *)&__m256i_result0) = 0x0000fffe00002001; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010080; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_w_hu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007f00; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7ffe7fffeffe; ++ *((unsigned long *)&__m256i_op01) = 0xffffd84900000849; ++ *((unsigned long *)&__m256i_op00) = 0x07fffc670800f086; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x311d9b643ec1fe01; ++ *((unsigned long *)&__m256i_op10) = 0x344ade20fe00fd01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007f00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x311d73ad3ec2064a; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff80cbfffffdf8; ++ *((unsigned long *)&__m256i_op12) = 0x0000081500000104; ++ *((unsigned long *)&__m256i_op11) = 0xffffffa4fffffffd; ++ *((unsigned long *)&__m256i_op10) = 0x0000000700000002; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff80cbfffffdf8; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffa4fffffffd; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op12) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op10) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000008050501; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_op02) = 0x019d00a20039fff9; ++ *((unsigned long *)&__m256i_op01) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_op00) = 0x019d00a2003a0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01fe007a01c40110; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x001ffffe00200000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x001ffffe00200000; ++ *((unsigned long *)&__m256i_op13) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff0020001d001f; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000fef0ff0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000fef0ff0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op13) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080ff0080; ++ *((unsigned long *)&__m256i_op11) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080ff0080; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x8000400080ffc080; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x007f010000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x007f010000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvaddwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-1.c +new file mode 100644 +index 000000000..2a4f29b50 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-1.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_op11) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_result1) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0xa020202020206431; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffee0000ff4c; ++ *((unsigned long *)&__m256i_op02) = 0x0000ff050000ff3c; ++ *((unsigned long *)&__m256i_op01) = 0x0000fff90000ff78; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffa80000ff31; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffee0000ff4c; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff050000ff3c; ++ *((unsigned long *)&__m256i_result1) = 0x0000fff90000ff78; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffa80000ff31; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff810011; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op02) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_result3) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_result2) = 0xff00000200000008; ++ *((unsigned long *)&__m256i_result1) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_result0) = 0xff00000200000008; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result2) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7efefefe80ffffff; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00007fde00007fd4; ++ *((unsigned long *)&__m256i_op02) = 0x00007fe000007fe0; ++ *((unsigned long *)&__m256i_op01) = 0x00007fde00007fd4; ++ *((unsigned long *)&__m256i_op00) = 0x00007fe000007fe0; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffff7eddffff7ed3; ++ *((unsigned long *)&__m256i_result2) = 0xffff7edfffff7edf; ++ *((unsigned long *)&__m256i_result1) = 0xffff7eddffff7ed3; ++ *((unsigned long *)&__m256i_result0) = 0xffff7edfffff7edf; ++ __m256i_out = __lasx_xvsadd_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffc81aca; ++ *((unsigned long *)&__m256i_op02) = 0x000000003a0a9512; ++ *((unsigned long *)&__m256i_op01) = 0x280ac9da313863f4; ++ *((unsigned long *)&__m256i_op00) = 0xe032c739adcc6bbd; ++ *((unsigned long *)&__m256i_op13) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100020001; ++ *((unsigned long *)&__m256i_op10) = 0x0000fffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0xfffdffffffc81aca; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff3a0b9512; ++ *((unsigned long *)&__m256i_result1) = 0x280bc9db313a63f5; ++ *((unsigned long *)&__m256i_result0) = 0xe032c738adcb6bbb; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1fe01e0100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x1fe01e0100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffffffa; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf800d0d8ffffeecf; ++ *((unsigned long *)&__m256i_op02) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256i_op01) = 0xf800d0d8ffffeecf; ++ *((unsigned long *)&__m256i_op00) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256i_op13) = 0xf000f000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xf000f000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xe800c0d8fffeeece; ++ *((unsigned long *)&__m256i_result2) = 0xffff383efffedf0c; ++ *((unsigned long *)&__m256i_result1) = 0xe800c0d8fffeeece; ++ *((unsigned long *)&__m256i_result0) = 0xffff383efffedf0c; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffe0000fffe0002; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffe0000fffe0002; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op12) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op11) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op10) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result3) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result2) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result1) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result0) = 0x7575757575757575; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fc00fc00; ++ *((unsigned long *)&__m256i_op11) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fc00fc00; ++ *((unsigned long *)&__m256i_result3) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fc00fc00; ++ *((unsigned long *)&__m256i_result1) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fc00fc00; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000007b00f9007e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000007b00f9007e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000007b00f9007e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000007b00f9007e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000f601f200fc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000f601f200fc; ++ __m256i_out = __lasx_xvsadd_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000007f00000022; ++ *((unsigned long *)&__m256i_op10) = 0x0000007f00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000007f00000022; ++ *((unsigned long *)&__m256i_result0) = 0x0000007f00000000; ++ __m256i_out = __lasx_xvsadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op02) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op01) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op00) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result2) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result1) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result0) = 0x1c1b1a191c1b1a19; ++ __m256i_out = __lasx_xvsadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_op02) = 0xffb7ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_op01) = 0x00010000002fff9e; ++ *((unsigned long *)&__m256i_op00) = 0xffb5ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_result2) = 0xffb7ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_result1) = 0x00010000002fff9e; ++ *((unsigned long *)&__m256i_result0) = 0xffb5ff80ffd0ffd8; ++ __m256i_out = __lasx_xvsadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff800000000000; ++ __m256i_out = __lasx_xvsadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvsadd_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op01) = 0x3fff3fff3fff4000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000403f3fff; ++ *((unsigned long *)&__m256i_op13) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op12) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op11) = 0x3fff3fff3fff4000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000403f3fff; ++ *((unsigned long *)&__m256i_result3) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m256i_result2) = 0x000000007ffe7ffe; ++ *((unsigned long *)&__m256i_result1) = 0x7ffe7ffe7ffe8000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000807e7ffe; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op02) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op01) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op00) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op13) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op12) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op11) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op10) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_result3) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result2) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result1) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result0) = 0xc2c2c2c2c2c2c2c2; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op12) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op11) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op10) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result3) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result2) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result1) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result0) = 0x7f807f007f7f817f; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op02) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op01) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op00) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op13) = 0x000000006040190d; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000006040190d; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000860601934; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_result1) = 0x0000000860601934; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800200028; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvadd_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-2.c +new file mode 100644 +index 000000000..a3afc9811 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsadd-2.c +@@ -0,0 +1,350 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001700080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001700080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001700080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001700080; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op12) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result3) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op01) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result2) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result0) = 0xf7f7f7f7f7f7f7f7; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000000; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x43d03bfff827ea21; ++ *((unsigned long *)&__m256i_op02) = 0x43dac1f2a3804ff0; ++ *((unsigned long *)&__m256i_op01) = 0x43d03bfff827e9f9; ++ *((unsigned long *)&__m256i_op00) = 0x43e019c657c7d050; ++ *((unsigned long *)&__m256i_op13) = 0x43d03bfff827ea21; ++ *((unsigned long *)&__m256i_op12) = 0x43dac1f2a3804ff0; ++ *((unsigned long *)&__m256i_op11) = 0x43d03bfff827e9f9; ++ *((unsigned long *)&__m256i_op10) = 0x43e019c657c7d050; ++ *((unsigned long *)&__m256i_result3) = 0x86ff76ffff4eff42; ++ *((unsigned long *)&__m256i_result2) = 0x86ffffffffff9eff; ++ *((unsigned long *)&__m256i_result1) = 0x86ff76ffff4effff; ++ *((unsigned long *)&__m256i_result0) = 0x86ff32ffaeffffa0; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff8910ffff7e01; ++ *((unsigned long *)&__m256i_op12) = 0xffff3573ffff8960; ++ *((unsigned long *)&__m256i_op11) = 0xffff8910ffff1ca9; ++ *((unsigned long *)&__m256i_op10) = 0xfffff5e5ffff8130; ++ *((unsigned long *)&__m256i_result3) = 0xffff8910ffff7e01; ++ *((unsigned long *)&__m256i_result2) = 0xffff3573ffff8960; ++ *((unsigned long *)&__m256i_result1) = 0xffff8910ffff1ca9; ++ *((unsigned long *)&__m256i_result0) = 0xfffff5e5ffff8130; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000f90; ++ __m256i_out = __lasx_xvsadd_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffe200000020; ++ *((unsigned long *)&__m256i_op02) = 0x0000fffe00008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffe200000020; ++ *((unsigned long *)&__m256i_op00) = 0x0000fffe00008000; ++ *((unsigned long *)&__m256i_op13) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op12) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op11) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op10) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result3) = 0x7575ffff75757595; ++ *((unsigned long *)&__m256i_result2) = 0x7575ffff7575f575; ++ *((unsigned long *)&__m256i_result1) = 0x7575ffff75757595; ++ *((unsigned long *)&__m256i_result0) = 0x7575ffff7575f575; ++ __m256i_out = __lasx_xvsadd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000f0f0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000f0f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000f0f0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000f0f0; ++ __m256i_out = __lasx_xvsadd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000001400; ++ *((unsigned long *)&__m256i_op12) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000001400; ++ *((unsigned long *)&__m256i_result2) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000003c01ff9; ++ __m256i_out = __lasx_xvsadd_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op02) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op01) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op00) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_result2) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_result1) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_result0) = 0x45c5c5c545c5c5c5; ++ __m256i_out = __lasx_xvsadd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvsadd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000080; ++ __m256i_out = __lasx_xvsadd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvsadd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsadd_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvand-xvandi-xvan.patch
Added
@@ -0,0 +1,1854 @@ +From ceef99197d4db1d34e5c8aeae2b5492d831685d0 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:42:34 +0800 +Subject: PATCH 105/124 LoongArch: Add tests for ASX vector + xvand/xvandi/xvandn/xvor/xvori/ xvnor/xvnori/xvxor/xvxori instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvand.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvandi.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvandn.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvnor.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvnori.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvor.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvori.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvorn.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvxor.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvxori.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvand.c | 155 +++++++++++ + .../loongarch/vector/lasx/lasx-xvandi.c | 196 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvandn.c | 125 +++++++++ + .../loongarch/vector/lasx/lasx-xvnor.c | 170 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvnori.c | 152 +++++++++++ + .../loongarch/vector/lasx/lasx-xvor.c | 215 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvori.c | 141 ++++++++++ + .../loongarch/vector/lasx/lasx-xvorn.c | 245 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvxor.c | 185 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvxori.c | 163 ++++++++++++ + 10 files changed, 1747 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvand.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnori.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvori.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvorn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxori.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvand.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvand.c +new file mode 100644 +index 000000000..e485786dd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvand.c +@@ -0,0 +1,155 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op12) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op10) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfefee00000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfefee00000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0xfefee00000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfefee00000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op13) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op12) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op11) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op10) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000001c; ++ __m256i_out = __lasx_xvand_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandi.c +new file mode 100644 +index 000000000..26cddc53a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandi.c +@@ -0,0 +1,196 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0xe2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000505; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256i_op02) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffff8d9ffa7103d; ++ *((unsigned long *)&__m256i_result3) = 0x001151510a431048; ++ *((unsigned long *)&__m256i_result2) = 0x5b0b08425b09011a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x5b5b58595b031019; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x5b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op02) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op00) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result3) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result2) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result0) = 0x0400040004000400; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff900000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff900000003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x3f3f3f3900000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x3f3f3f3900000003; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result2) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result1) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result0) = 0xbabababababababa; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0xba); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_result3) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result2) = 0x4000404040004040; ++ *((unsigned long *)&__m256i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result0) = 0x4000404040004040; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x40); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff3c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff31; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x5e5e5e5e5e5e5e1c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x5e5e5e5e5e5e5e10; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x5e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x86); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7f70000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x7f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0xa3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0x98); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0xd9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandi_b (__m256i_op0, 0xcc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandn.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandn.c +new file mode 100644 +index 000000000..bc3590c21 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvandn.c +@@ -0,0 +1,125 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x1828f0e09bad7249; ++ *((unsigned long *)&__m256i_op02) = 0x07ffc1b723953cec; ++ *((unsigned long *)&__m256i_op01) = 0x61f2e9b333aab104; ++ *((unsigned long *)&__m256i_op00) = 0x6bf742aa0d7856a0; ++ *((unsigned long *)&__m256i_op13) = 0x000019410000e69a; ++ *((unsigned long *)&__m256i_op12) = 0xf259905a09c23be0; ++ *((unsigned long *)&__m256i_op11) = 0x0000883a00000f20; ++ *((unsigned long *)&__m256i_op10) = 0x6d3c2d3a89167aeb; ++ *((unsigned long *)&__m256i_result3) = 0x0000090100008492; ++ *((unsigned long *)&__m256i_result2) = 0xf000104808420300; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800000e20; ++ *((unsigned long *)&__m256i_result0) = 0x04082d108006284b; ++ __m256i_out = __lasx_xvandn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffdfffdfffdfffd; ++ __m256i_out = __lasx_xvandn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op02) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op01) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op00) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_result2) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_result1) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_result0) = 0xefdfefdfefdfefdf; ++ __m256i_out = __lasx_xvandn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvandn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d6d6d; ++ __m256i_out = __lasx_xvandn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvandn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnor.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnor.c +new file mode 100644 +index 000000000..3a491ecab +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnor.c +@@ -0,0 +1,170 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0x40d74f979f99419f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0xbf28b0686066be60; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffff6ff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffff6ff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000900ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000900ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8888888808888888; ++ *((unsigned long *)&__m256i_op02) = 0x0888888888888888; ++ *((unsigned long *)&__m256i_op01) = 0x8888888808888888; ++ *((unsigned long *)&__m256i_op00) = 0x0888888888888888; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x77777777f7777777; ++ *((unsigned long *)&__m256i_result2) = 0xf777777777777777; ++ *((unsigned long *)&__m256i_result1) = 0x77777777f7777777; ++ *((unsigned long *)&__m256i_result0) = 0xf777777777777777; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x40ff40ff40ff40ff; ++ *((unsigned long *)&__m256i_op02) = 0x407b40ff40ff40f1; ++ *((unsigned long *)&__m256i_op01) = 0x40ff40ff40ff40ff; ++ *((unsigned long *)&__m256i_op00) = 0x407b40ff40ff40f1; ++ *((unsigned long *)&__m256i_op13) = 0x40ff40ff40ff40ff; ++ *((unsigned long *)&__m256i_op12) = 0x407b40ff40ff40f1; ++ *((unsigned long *)&__m256i_op11) = 0x40ff40ff40ff40ff; ++ *((unsigned long *)&__m256i_op10) = 0x407b40ff40ff40f1; ++ *((unsigned long *)&__m256i_result3) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_result2) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_result1) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_result0) = 0xbf84bf00bf00bf0e; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_op13) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op12) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op11) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op10) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffbdff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0xa000a0009f80ffcc; ++ *((unsigned long *)&__m256i_result1) = 0x7fffbdff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0xa000a0009f80ffcc; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op02) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op01) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op00) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op13) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op12) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op11) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op10) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result3) = 0x6f6f6f6f6f6f6f6f; ++ *((unsigned long *)&__m256i_result2) = 0x6f6f6f6f6f6f6f6f; ++ *((unsigned long *)&__m256i_result1) = 0x6f6f6f6f6f6f6f6f; ++ *((unsigned long *)&__m256i_result0) = 0x6f6f6f6f6f6f6f6f; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_result3) = 0xffff000300030000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffc000; ++ *((unsigned long *)&__m256i_result1) = 0xffff000300030000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffc000; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x800fffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x800fffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x800fffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x800fffffffffffff; ++ __m256i_out = __lasx_xvnor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnori.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnori.c +new file mode 100644 +index 000000000..995a34c18 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvnori.c +@@ -0,0 +1,152 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_result2) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_result1) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_result0) = 0x45c5c5c545c5c5c5; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007773; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000003373; ++ *((unsigned long *)&__m256i_result3) = 0xbbbbbbbbbbbbbbbb; ++ *((unsigned long *)&__m256i_result2) = 0xbbbbbbbbbbbb8888; ++ *((unsigned long *)&__m256i_result1) = 0xbbbbbbbbbbbbbbbb; ++ *((unsigned long *)&__m256i_result0) = 0xbbbbbbbbbbbb8888; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x44); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result2) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result0) = 0xf7f7f7f7f7f7f7f7; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xdededededededede; ++ *((unsigned long *)&__m256i_result2) = 0xdededededededede; ++ *((unsigned long *)&__m256i_result1) = 0xdededededededede; ++ *((unsigned long *)&__m256i_result0) = 0xdededededededede; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x21); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x33); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result2) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result1) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result0) = 0x9090909090909090; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x6f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0xf7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x5858585858585858; ++ *((unsigned long *)&__m256i_result2) = 0x5858585858585858; ++ *((unsigned long *)&__m256i_result1) = 0x5858585858585858; ++ *((unsigned long *)&__m256i_result0) = 0x5858585858585858; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0xa7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_result2) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_result1) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_result0) = 0x3d3d3d3d3d3d3d3d; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0xc2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x9d9d9d9d9d9d9d8d; ++ *((unsigned long *)&__m256i_result2) = 0x9d9d9d9d9d9d9d9d; ++ *((unsigned long *)&__m256i_result1) = 0x9d9d9d9d9d9d9d8d; ++ *((unsigned long *)&__m256i_result0) = 0x9d9d9d9d9d9d9d9d; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x62); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_result2) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_result1) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_result0) = 0x2a2a2a2a2a2a2a2a; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0xd5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000081220000812c; ++ *((unsigned long *)&__m256i_op02) = 0x0000812000008120; ++ *((unsigned long *)&__m256i_op01) = 0x000081220000812c; ++ *((unsigned long *)&__m256i_op00) = 0x0000812000008120; ++ *((unsigned long *)&__m256i_result3) = 0xe9e968c9e9e968c1; ++ *((unsigned long *)&__m256i_result2) = 0xe9e968c9e9e968c9; ++ *((unsigned long *)&__m256i_result1) = 0xe9e968c9e9e968c1; ++ *((unsigned long *)&__m256i_result0) = 0xe9e968c9e9e968c9; ++ __m256i_out = __lasx_xvnori_b (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvor.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvor.c +new file mode 100644 +index 000000000..27eef710d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvor.c +@@ -0,0 +1,215 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_op00) = 0x00007fff7fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_op10) = 0x00007fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff7fff7fff; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000005e02; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000005e02; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000005e02; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000005e02; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op12) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op11) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_result3) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result2) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_result1) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000089; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fe37fff001fffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fe37fff001fffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fffffff; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x003f60041f636003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x003f60041f636003; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op12) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op11) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op10) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result3) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result2) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result1) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result0) = 0xfff1fff1fff1fff1; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00ff00ff; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x800080ff800080ff; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff80007fff0000; ++ __m256i_out = __lasx_xvor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvori.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvori.c +new file mode 100644 +index 000000000..ee91af95f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvori.c +@@ -0,0 +1,141 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x6c6c6c6c6c6c6c6c; ++ *((unsigned long *)&__m256i_result2) = 0x6c6c6c6c6c6c6c6c; ++ *((unsigned long *)&__m256i_result1) = 0x6c6c6c6c6c6c6c6c; ++ *((unsigned long *)&__m256i_result0) = 0x6c6c6c6c6c6c6c6c; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x6c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffff00fffffff0; ++ *((unsigned long *)&__m256i_result3) = 0x9f9f9f9f9f9f9f9f; ++ *((unsigned long *)&__m256i_result2) = 0x9f9f9f9fffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x9f9f9f9f9f9f9f9f; ++ *((unsigned long *)&__m256i_result0) = 0xffffff9fffffffff; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x9f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x6a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffff7effffff46; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffff7effffff46; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x42); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result2) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result1) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result0) = 0xbfbfbfbfbfbfbfbf; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0xbf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x2c2c2c2c2c2c2c2c; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x2c2c2c2c2c2c2c2c; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x5252525252525252; ++ *((unsigned long *)&__m256i_result2) = 0x5252525252525252; ++ *((unsigned long *)&__m256i_result1) = 0x5252525252525252; ++ *((unsigned long *)&__m256i_result0) = 0x5252525252525252; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x52); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op02) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_result3) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_result2) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_result1) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_result0) = 0x7fe363637fe36363; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x63); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_result3) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefeffe0e0e0; ++ *((unsigned long *)&__m256i_result1) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefeffe0e0e0; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0xe0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_result2) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_result1) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_result0) = 0x6b6b6b6b6b6b6b6b; ++ __m256i_out = __lasx_xvori_b (__m256i_op0, 0x6b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvorn.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvorn.c +new file mode 100644 +index 000000000..fa6cdff31 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvorn.c +@@ -0,0 +1,245 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0xbf28b0686066be60; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x40d74f979f99419f; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x01480000052801a2; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffdcff64; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op12) = 0x0002555500000000; ++ *((unsigned long *)&__m256i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op10) = 0x0002555500000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffdaaaaffffffff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000236200005111; ++ *((unsigned long *)&__m256i_op02) = 0x0000175e0000490d; ++ *((unsigned long *)&__m256i_op01) = 0x0000236200005111; ++ *((unsigned long *)&__m256i_op00) = 0x0000175e0000490d; ++ *((unsigned long *)&__m256i_op13) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op12) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_op11) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op10) = 0x00220021004a007e; ++ *((unsigned long *)&__m256i_result3) = 0xfffdfffffffdffff; ++ *((unsigned long *)&__m256i_result2) = 0xffddffdeffb5ff8d; ++ *((unsigned long *)&__m256i_result1) = 0xfffdfffffffdffff; ++ *((unsigned long *)&__m256i_result0) = 0xffddffdeffb5ff8d; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op13) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_op12) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_op11) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_op10) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0xff00feffff00fe81; ++ *((unsigned long *)&__m256i_result2) = 0xfe01fe51ff00ff40; ++ *((unsigned long *)&__m256i_result1) = 0xff00feffff00fe81; ++ *((unsigned long *)&__m256i_result0) = 0xfe01fe51ff00ff40; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0df9f8e; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe0df9f8e; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffe0df9f8f; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffe0df9f8f; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff7fffffff7fff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff7fffffff7fff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xdf80df80df80dfff; ++ *((unsigned long *)&__m256i_op12) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffdf80dfff; ++ *((unsigned long *)&__m256i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x498100814843ffe1; ++ *((unsigned long *)&__m256i_op02) = 0x4981008168410001; ++ *((unsigned long *)&__m256i_op01) = 0x498100814843ffe1; ++ *((unsigned long *)&__m256i_op00) = 0x4981008168410001; ++ *((unsigned long *)&__m256i_op13) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256i_op12) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256i_op10) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff896099cbdbfff1; ++ *((unsigned long *)&__m256i_result2) = 0xc987ffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xff896099cbdbfff1; ++ *((unsigned long *)&__m256i_result0) = 0xc987ffffffffffff; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_op12) = 0xffffdf5b000041b0; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_op10) = 0xffffdf5b000041b0; ++ *((unsigned long *)&__m256i_result3) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_result2) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_result1) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_result0) = 0x000020a4ffffbe4f; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op13) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op11) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0xffbffffffffffffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_result1) = 0xffbffffffffffffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffffa; ++ __m256i_out = __lasx_xvorn_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxor.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxor.c +new file mode 100644 +index 000000000..18b36c873 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxor.c +@@ -0,0 +1,185 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256i_op12) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256i_op11) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256i_result2) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256i_result1) = 0x7be2468acf15f39c; ++ *((unsigned long *)&__m256i_result0) = 0x7ff0000000000000; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00c100c100c100c1; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00c100c100c100c1; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0100000001000100; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000f91; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000f91; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000f90; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op02) = 0x6040190d20227a78; ++ *((unsigned long *)&__m256i_op01) = 0x132feeabd2d33b38; ++ *((unsigned long *)&__m256i_op00) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x9fe7fffffffff32e; ++ *((unsigned long *)&__m256i_result2) = 0x6040190ddfdd8587; ++ *((unsigned long *)&__m256i_result1) = 0xecd011542d2cc4c7; ++ *((unsigned long *)&__m256i_result0) = 0x6040190dffffffff; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000101000001010; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvxor_v (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxori.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxori.c +new file mode 100644 +index 000000000..8fd6298f7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvxori.c +@@ -0,0 +1,163 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000005e02; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000005e02; ++ *((unsigned long *)&__m256i_result3) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result2) = 0xc2c2c2c2c2c29cc0; ++ *((unsigned long *)&__m256i_result1) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result0) = 0xc2c2c2c2c2c29cc0; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0xc2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1616161616161616; ++ *((unsigned long *)&__m256i_op02) = 0x161616167fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe16167f161616; ++ *((unsigned long *)&__m256i_op00) = 0x161616167fffffff; ++ *((unsigned long *)&__m256i_result3) = 0xc7c7c7c7c7c7c7c7; ++ *((unsigned long *)&__m256i_result2) = 0xc7c7c7c7ae2e2e2e; ++ *((unsigned long *)&__m256i_result1) = 0xae2fc7c7aec7c7c7; ++ *((unsigned long *)&__m256i_result0) = 0xc7c7c7c7ae2e2e2e; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0xd1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x5353535353535353; ++ *((unsigned long *)&__m256i_result2) = 0x5353535353535353; ++ *((unsigned long *)&__m256i_result1) = 0x5353535353535353; ++ *((unsigned long *)&__m256i_result0) = 0x5353535353535353; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0x53); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x6d6d6d6d6d6d6d6d; ++ *((unsigned long *)&__m256i_result2) = 0x6d6d6d6d6d6d6d6d; ++ *((unsigned long *)&__m256i_result1) = 0x6d6d6d6d6d6d6d6d; ++ *((unsigned long *)&__m256i_result0) = 0x6d6d6d6d6d6d6d6d; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0x6d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_result2) = 0x8e8e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_result1) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_result0) = 0x8e8e8e8e8e8e8e8e; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0x71); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result2) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result1) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result0) = 0x7575757575757575; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0x75); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xa4a4a4a4a4a4a4a4; ++ *((unsigned long *)&__m256i_result2) = 0xa4a4a4a4a4a4a4a4; ++ *((unsigned long *)&__m256i_result1) = 0xa4a4a4a4a4a4a4a4; ++ *((unsigned long *)&__m256i_result0) = 0xa4a4a4a4a4a4a4a4; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0xa4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_result2) = 0xa1a1a1a15e5e5e5e; ++ *((unsigned long *)&__m256i_result1) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_result0) = 0xa1a1a1a15e5e5e5e; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0xa1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x8d8d72728d8d7272; ++ *((unsigned long *)&__m256i_result2) = 0x8d8d72728d8d8d8d; ++ *((unsigned long *)&__m256i_result1) = 0x8d8d72728d8d7272; ++ *((unsigned long *)&__m256i_result0) = 0x8d8d72728d8d8d8d; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0x8d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xb3b3b3b3b3b3b3b3; ++ *((unsigned long *)&__m256i_result2) = 0xb3b3b3b3b3b3b3b3; ++ *((unsigned long *)&__m256i_result1) = 0xb3b3b3b3b3b3b3b3; ++ *((unsigned long *)&__m256i_result0) = 0xb3b3b3b3b3b3b3b3; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0x4c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_op02) = 0x007f0000ff807f81; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_op00) = 0x007f0000ff807f81; ++ *((unsigned long *)&__m256i_result3) = 0x5d5d5d5d5d22a2a2; ++ *((unsigned long *)&__m256i_result2) = 0xa2dda2a25d22dd23; ++ *((unsigned long *)&__m256i_result1) = 0x5d5d5d5d5d22a2a2; ++ *((unsigned long *)&__m256i_result0) = 0xa2dda2a25d22dd23; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0xa2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xd3d3d3d3d3d3d3d3; ++ *((unsigned long *)&__m256i_result2) = 0xd3d3d3d3d3d3d3d3; ++ *((unsigned long *)&__m256i_result1) = 0xd3d3d3d3d3d3d3d3; ++ *((unsigned long *)&__m256i_result0) = 0xd3d3d3d3d3d3d3d3; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0xd3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_result3) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_result2) = 0x8768876887688769; ++ *((unsigned long *)&__m256i_result1) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_result0) = 0x8768876887688769; ++ __m256i_out = __lasx_xvxori_b (__m256i_op0, 0x7d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvbitclr-xvbitclr.patch
Added
@@ -0,0 +1,5057 @@ +From a6390d1a6619b6bee4fc87b15ffd25936704eb21 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:57:18 +0800 +Subject: PATCH 108/124 LoongArch: Add tests for ASX vector + xvbitclr/xvbitclri/xvbitrev/xvbitrevi/ + xvbitsel/xvbitseli/xvbitset/xvbitseti/xvclo/xvclz/xvpcnt instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvbitclr.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbitclri.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbitrev.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbitrevi.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbitsel.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbitseli.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbitset.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvbitseti.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvclo.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvclz.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvpcnt.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvbitclr.c | 635 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvbitclri.c | 515 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvbitrev.c | 650 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvbitrevi.c | 317 +++++++++ + .../loongarch/vector/lasx/lasx-xvbitsel.c | 134 ++++ + .../loongarch/vector/lasx/lasx-xvbitseli.c | 185 +++++ + .../loongarch/vector/lasx/lasx-xvbitset.c | 620 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvbitseti.c | 405 +++++++++++ + .../loongarch/vector/lasx/lasx-xvclo.c | 449 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvclz.c | 504 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvpcnt.c | 526 ++++++++++++++ + 11 files changed, 4940 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclri.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrev.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrevi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitsel.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseli.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitset.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseti.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclo.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclz.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpcnt.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclr.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclr.c +new file mode 100644 +index 000000000..def7b588e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclr.c +@@ -0,0 +1,635 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000040000fff8; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffff1f; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffeff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffff1f; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffeff; ++ *((unsigned long *)&__m256i_op13) = 0x00000105fffffefb; ++ *((unsigned long *)&__m256i_op12) = 0xffffff02000000fe; ++ *((unsigned long *)&__m256i_op11) = 0x00000105fffffefb; ++ *((unsigned long *)&__m256i_op10) = 0xffffff02000000fe; ++ *((unsigned long *)&__m256i_result3) = 0xf7ffffffffffff1f; ++ *((unsigned long *)&__m256i_result2) = 0xbffffffffffffeff; ++ *((unsigned long *)&__m256i_result1) = 0xf7ffffffffffff1f; ++ *((unsigned long *)&__m256i_result0) = 0xbffffffffffffeff; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fff7fff7fffdefd; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvbitclr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op02) = 0x0002555500000000; ++ *((unsigned long *)&__m256i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op00) = 0x0002555500000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result2) = 0x0002555400000000; ++ *((unsigned long *)&__m256i_result1) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result0) = 0x0002555400000000; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000002a542a; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op12) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op11) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op10) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0002000200020002; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256i_op02) = 0x00000fff00004542; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256i_op00) = 0x00000fff00004542; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256i_result2) = 0x00000fff00004542; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256i_result0) = 0x00000fff00004542; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op02) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op01) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op00) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_op11) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_result3) = 0xff00fe00feff02fe; ++ *((unsigned long *)&__m256i_result2) = 0xff00fe00feff027f; ++ *((unsigned long *)&__m256i_result1) = 0xff00fe00feff02fe; ++ *((unsigned long *)&__m256i_result0) = 0xff00fe00feff027f; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op02) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op00) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op13) = 0x000023a20000a121; ++ *((unsigned long *)&__m256i_op12) = 0x0000179e0000951d; ++ *((unsigned long *)&__m256i_op11) = 0x000023a20000a121; ++ *((unsigned long *)&__m256i_op10) = 0x0000179e0000951d; ++ *((unsigned long *)&__m256i_result3) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result2) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000000100; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000236200005111; ++ *((unsigned long *)&__m256i_op02) = 0x0000175e0000490d; ++ *((unsigned long *)&__m256i_op01) = 0x0000236200005111; ++ *((unsigned long *)&__m256i_op00) = 0x0000175e0000490d; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffeeffaf; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffeeffaf; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_result3) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_result2) = 0x0000165e0000480d; ++ *((unsigned long *)&__m256i_result1) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_result0) = 0x0000165e0000480d; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007fef; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007fef; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000007fef; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000007fef; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007fee; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffff00; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffff00; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fefe7f00; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fefe7f00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00001fff200007ef; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff00000000; ++ __m256i_out = __lasx_xvbitclr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffefffe00000000; ++ __m256i_out = __lasx_xvbitclr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fe70000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fe70000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fe70000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fe70000; ++ *((unsigned long *)&__m256i_result3) = 0x00007f7f80007fa3; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f670000; ++ *((unsigned long *)&__m256i_result1) = 0x00007f7f80007fa3; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f670000; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffeffff10000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffeffff10000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7ffffffffffffffe; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7ffffffffffffffe; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op02) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x3e8000003e800000; ++ *((unsigned long *)&__m256i_result2) = 0x3e8000003e800000; ++ *((unsigned long *)&__m256i_result1) = 0x3e8000003e800000; ++ *((unsigned long *)&__m256i_result0) = 0x3e8000003e800000; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00001ff8d8d8c000; ++ *((unsigned long *)&__m256i_op02) = 0x00001ff8d8d90000; ++ *((unsigned long *)&__m256i_op01) = 0x00001ff8d8d8c000; ++ *((unsigned long *)&__m256i_op00) = 0x00001ff8d8d90000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00001ef8d8d8c000; ++ *((unsigned long *)&__m256i_result2) = 0x00001ef8d8d80000; ++ *((unsigned long *)&__m256i_result1) = 0x00001ef8d8d8c000; ++ *((unsigned long *)&__m256i_result0) = 0x00001ef8d8d80000; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000fffe0000000c; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffe0000000c; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000003; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op12) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_result3) = 0xfefee00000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfefee00000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000fff000000000; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ffff88ff88; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op02) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op00) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result2) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result0) = 0xff00ff007f007f00; ++ __m256i_out = __lasx_xvbitclr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_op01) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffeffffff00; ++ *((unsigned long *)&__m256i_result1) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffeffffff00; ++ __m256i_out = __lasx_xvbitclr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclri.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclri.c +new file mode 100644 +index 000000000..713eb19d5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitclri.c +@@ -0,0 +1,515 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe06df8d7; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffbe8b470f; ++ *((unsigned long *)&__m256i_result3) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffe06df0d7; ++ *((unsigned long *)&__m256i_result1) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffbe8b470f; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010ffc80010ff52; ++ *((unsigned long *)&__m256i_op02) = 0xfff1ffca0011ffcb; ++ *((unsigned long *)&__m256i_op01) = 0x0010ffc80010ff52; ++ *((unsigned long *)&__m256i_op00) = 0xfff1ffca0011ffcb; ++ *((unsigned long *)&__m256i_result3) = 0x0010bfc80010bf52; ++ *((unsigned long *)&__m256i_result2) = 0xfff1bfca0011bfcb; ++ *((unsigned long *)&__m256i_result1) = 0x0010bfc80010bf52; ++ *((unsigned long *)&__m256i_result0) = 0xfff1bfca0011bfcb; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000005536aaaaac; ++ *((unsigned long *)&__m256i_op02) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op01) = 0x0000005536aaaaac; ++ *((unsigned long *)&__m256i_op00) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_result3) = 0x0000005136aaaaa8; ++ *((unsigned long *)&__m256i_result2) = 0x55515551aaaaaaa8; ++ *((unsigned long *)&__m256i_result1) = 0x0000005136aaaaa8; ++ *((unsigned long *)&__m256i_result0) = 0x55515551aaaaaaa8; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fdf000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fdf000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fdf7fff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fdf7fff00000000; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0x35); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000fd0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000fd0000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m256i_op02) = 0x000000007ffe7ffe; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe7ffe7ffe8000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000807e7ffe; ++ *((unsigned long *)&__m256i_result3) = 0x7f7e7f7e7f7e7f7e; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f7e7f7e; ++ *((unsigned long *)&__m256i_result1) = 0x7f7e7f7e7f7e0000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007e7f7e; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0x24); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf01010153a10101; ++ *((unsigned long *)&__m256i_op02) = 0x5b7f01ff5b7f10ff; ++ *((unsigned long *)&__m256i_op01) = 0xdf01010153a10101; ++ *((unsigned long *)&__m256i_op00) = 0x5b7f01ff5b7f10ff; ++ *((unsigned long *)&__m256i_result3) = 0xcf01010143a10101; ++ *((unsigned long *)&__m256i_result2) = 0x4b6f01ef4b6f00ef; ++ *((unsigned long *)&__m256i_result1) = 0xcf01010143a10101; ++ *((unsigned long *)&__m256i_result0) = 0x4b6f01ef4b6f00ef; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0xdfffffffdfffffff; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0xdfffffffdfffffff; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff02ff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0100; ++ *((unsigned long *)&__m256i_op00) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff7fff7f; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff7f027f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff7f0100; ++ *((unsigned long *)&__m256i_result0) = 0xff00fe00fe7f027f; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8011ffee804c004c; ++ *((unsigned long *)&__m256i_op02) = 0x00faff0500c3ff3c; ++ *((unsigned long *)&__m256i_op01) = 0x80f900f980780078; ++ *((unsigned long *)&__m256i_op00) = 0x0057ffa800ceff31; ++ *((unsigned long *)&__m256i_result3) = 0x8011ffae800c000c; ++ *((unsigned long *)&__m256i_result2) = 0x00baff050083ff3c; ++ *((unsigned long *)&__m256i_result1) = 0x80b900b980380038; ++ *((unsigned long *)&__m256i_result0) = 0x0017ffa8008eff31; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_op02) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_op00) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_result2) = 0x23222120171e151c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_result0) = 0x23222120171e151c; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000fefe0000fefe; ++ *((unsigned long *)&__m256i_result2) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000fefe0000fefe; ++ *((unsigned long *)&__m256i_result0) = 0x00fe00fe00fe00fe; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0x26); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op02) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op01) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op00) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result3) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result2) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result1) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result0) = 0x7fe1ffe0ffe1ffe0; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_d (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffffb; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffffffb; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op02) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op01) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op00) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800200028; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffee00ba; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffee00ba; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xefefefefefee00aa; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xefefefefefee00aa; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op02) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op00) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100010; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000f788f788; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000f788f788; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitclri_w (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffefffefffefffe; ++ __m256i_out = __lasx_xvbitclri_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrev.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrev.c +new file mode 100644 +index 000000000..2b0e7f8d1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrev.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0501030102141923; ++ *((unsigned long *)&__m256i_op02) = 0xffd5020738b43ddb; ++ *((unsigned long *)&__m256i_op01) = 0x010200023b8e4174; ++ *((unsigned long *)&__m256i_op00) = 0xfff4ff4e11410b40; ++ *((unsigned long *)&__m256i_op13) = 0x01fa022a01a401e5; ++ *((unsigned long *)&__m256i_op12) = 0x030d03aa0079029b; ++ *((unsigned long *)&__m256i_op11) = 0x024c01f901950261; ++ *((unsigned long *)&__m256i_op10) = 0x008102c2008a029f; ++ *((unsigned long *)&__m256i_result3) = 0x0101070102041903; ++ *((unsigned long *)&__m256i_result2) = 0xdfd506073ab435db; ++ *((unsigned long *)&__m256i_result1) = 0x110202023bae4176; ++ *((unsigned long *)&__m256i_result0) = 0xfff6ff4a15418b40; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0edf8d7; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffbe8bc70f; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffe0edf8d7; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffbe8bc70f; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffe06df8d7; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffbe8b470f; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_result3) = 0x000000010000ffe1; ++ *((unsigned long *)&__m256i_result2) = 0x0000000101001e18; ++ *((unsigned long *)&__m256i_result1) = 0x000000010000ffe1; ++ *((unsigned long *)&__m256i_result0) = 0x0000000101001e18; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefefefefefe; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op02) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op01) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op00) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x1d1a1b181d1a1b18; ++ *((unsigned long *)&__m256i_result2) = 0x9c9b9a999c9b9a99; ++ *((unsigned long *)&__m256i_result1) = 0x1d1a1b181d1a1b18; ++ *((unsigned long *)&__m256i_result0) = 0x9c9b9a999c9b9a99; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000033e87ef1; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002e2100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x80008000b3e8fef1; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x80008000802ea100; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1c80780000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op11) = 0x1c80780000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0200000200000000; ++ *((unsigned long *)&__m256i_op12) = 0x2c27000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0200000200000000; ++ *((unsigned long *)&__m256i_op10) = 0x2c27000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000400000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000400000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x8000800080008000; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff00ff00ffff00; ++ *((unsigned long *)&__m256i_op12) = 0xff000000ff00ff00; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffff00ffff; ++ *((unsigned long *)&__m256i_op10) = 0xff00000000ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000180000000; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x8001800180018001; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x8001800180018001; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op01) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000003; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256i_result1) = 0x0080000200000003; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00010002; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op01) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f6f7f7f7f6; ++ *((unsigned long *)&__m256i_result2) = 0xf7f7f7f6f7f7f7f6; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f6f7f7f7f6; ++ *((unsigned long *)&__m256i_result0) = 0xf7f7f7f6f7f7f7f6; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7eeefefefefefefe; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x7eeefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000010000fffe; ++ *((unsigned long *)&__m256i_result2) = 0x000000010000fffe; ++ *((unsigned long *)&__m256i_result1) = 0x000000010000fffe; ++ *((unsigned long *)&__m256i_result0) = 0x000000010000fffe; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000004; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitrev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000008000b; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op01) = 0x000000000008000b; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000008000a; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000a; ++ *((unsigned long *)&__m256i_result1) = 0x000000000008000a; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000a; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x000100010001fffe; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x000100010001fffe; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op02) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op01) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op00) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op13) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op12) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op11) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op10) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result3) = 0x40fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result2) = 0x40fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result1) = 0x40fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result0) = 0x40fe00fe00fe00fe; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffc0007ffe0002; ++ *((unsigned long *)&__m256i_result2) = 0x8000400000018002; ++ *((unsigned long *)&__m256i_result1) = 0xffffc0007ffe0002; ++ *((unsigned long *)&__m256i_result0) = 0x8000400000018002; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefe01010101; ++ *((unsigned long *)&__m256i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefe01010101; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000006d; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000400008; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000006d; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000400008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op12) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op10) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_result3) = 0x010101010101016c; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101410128; ++ *((unsigned long *)&__m256i_result1) = 0x010101010101016c; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101410128; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x800000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x800000ff000000ff; ++ __m256i_out = __lasx_xvbitrev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffb6811fffff80; ++ *((unsigned long *)&__m256i_op02) = 0xffff97c120000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffb6811fffff80; ++ *((unsigned long *)&__m256i_op00) = 0xffff97c120000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op12) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op11) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op10) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result3) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_result2) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result1) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_result0) = 0xfffe97c020010001; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_result3) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefefefefe7f; ++ *((unsigned long *)&__m256i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefefefefe7f; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010003; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010081; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010003; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100018080; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010110; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010110; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitrev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvbitrev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrevi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrevi.c +new file mode 100644 +index 000000000..2b8327d91 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitrevi.c +@@ -0,0 +1,317 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff00ff00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff00ff00; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x01010101fe01fe01; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x01010101fe01fe01; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_result2) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_result1) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_result0) = 0x2000200020002000; ++ __m256i_out = __lasx_xvbitrevi_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7ff77fff7ff7; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7ff77fff7ff7; ++ __m256i_out = __lasx_xvbitrevi_w (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000020001; ++ *((unsigned long *)&__m256i_result3) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result2) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result1) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result0) = 0x1010101010121011; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitrevi_d (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000004000000040; ++ __m256i_out = __lasx_xvbitrevi_w (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000020000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000020000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000020000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000020000000000; ++ __m256i_out = __lasx_xvbitrevi_d (__m256i_op0, 0x29); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result2) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result0) = 0x4040404040404040; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001c4e8ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001c4e8ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_result2) = 0x0081c4e8ff7fffff; ++ *((unsigned long *)&__m256i_result1) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_result0) = 0x0081c4e8ff7fffff; ++ __m256i_out = __lasx_xvbitrevi_w (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_result3) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f7f017ffd; ++ *((unsigned long *)&__m256i_result1) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result0) = 0x7f7f7f7f7f017ffd; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x4000000000000000; ++ __m256i_out = __lasx_xvbitrevi_d (__m256i_op0, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002080100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002080100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000008000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000a080100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000008000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000a080100; ++ __m256i_out = __lasx_xvbitrevi_d (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result2) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result1) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result0) = 0x0100010001000100; ++ __m256i_out = __lasx_xvbitrevi_h (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op02) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_op01) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op00) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_result3) = 0xfee1057c01e10581; ++ *((unsigned long *)&__m256i_result2) = 0x011ec1210161057b; ++ *((unsigned long *)&__m256i_result1) = 0xfee1057c01e10581; ++ *((unsigned long *)&__m256i_result0) = 0x011ec1210161057b; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result3) = 0xfdfdfdfdfdfdfdfd; ++ *((unsigned long *)&__m256i_result2) = 0xe27fe2821d226278; ++ *((unsigned long *)&__m256i_result1) = 0xfdfdfdfdfdfdfdfd; ++ *((unsigned long *)&__m256i_result0) = 0xe27fe2821d226278; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvbitrevi_w (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800000008; ++ __m256i_out = __lasx_xvbitrevi_w (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op02) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op01) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op00) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_result3) = 0x080808000828082f; ++ *((unsigned long *)&__m256i_result2) = 0x0808080008280820; ++ *((unsigned long *)&__m256i_result1) = 0x080808000828082f; ++ *((unsigned long *)&__m256i_result0) = 0x0808080008280820; ++ __m256i_out = __lasx_xvbitrevi_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvbitrevi_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000800000000000; ++ __m256i_out = __lasx_xvbitrevi_d (__m256i_op0, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0200000002000000; ++ *((unsigned long *)&__m256i_result2) = 0x02000000fdffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0200000002000000; ++ *((unsigned long *)&__m256i_result0) = 0x02000000fdffffff; ++ __m256i_out = __lasx_xvbitrevi_w (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffeffed; ++ __m256i_out = __lasx_xvbitrevi_d (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xc03b000200020002; ++ *((unsigned long *)&__m256i_result2) = 0xc03b000200020002; ++ *((unsigned long *)&__m256i_result1) = 0xc03b000200020002; ++ *((unsigned long *)&__m256i_result0) = 0xc03b000200020002; ++ __m256i_out = __lasx_xvbitrevi_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result2) = 0x7fff81007fff0100; ++ *((unsigned long *)&__m256i_result1) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_result0) = 0x7fff81007fff0100; ++ __m256i_out = __lasx_xvbitrevi_w (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitsel.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitsel.c +new file mode 100644 +index 000000000..c9847a615 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitsel.c +@@ -0,0 +1,134 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xe9e9e9e9e9e9e9e9; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xe9e9e9e9e9e9e9e9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitsel_v (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitsel_v (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op02) = 0x001f001f02c442af; ++ *((unsigned long *)&__m256i_op01) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op00) = 0x001f001f02c442af; ++ *((unsigned long *)&__m256i_op13) = 0x00fe01f000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00fe01f000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_op21) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_result3) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_result1) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000c40086; ++ __m256i_out = __lasx_xvbitsel_v (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op13) = 0xbe21000100000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000505300000000; ++ *((unsigned long *)&__m256i_op11) = 0xbe21000100000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000505300000000; ++ *((unsigned long *)&__m256i_op23) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op22) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_op21) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op20) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x00005053000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x00005053000000ff; ++ __m256i_out = __lasx_xvbitsel_v (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000040000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000040000; ++ *((unsigned long *)&__m256i_op23) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000040000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000040000; ++ __m256i_out = __lasx_xvbitsel_v (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvbitsel_v (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseli.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseli.c +new file mode 100644 +index 000000000..1edb4fca2 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseli.c +@@ -0,0 +1,185 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0xef); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0xcd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffd10000006459; ++ *((unsigned long *)&__m256i_op02) = 0x0000441000000004; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op00) = 0x0000040400000104; ++ *((unsigned long *)&__m256i_op13) = 0xdb801b6d0962003f; ++ *((unsigned long *)&__m256i_op12) = 0xdb8a3109fe0f0024; ++ *((unsigned long *)&__m256i_op11) = 0x0000007fff01ffff; ++ *((unsigned long *)&__m256i_op10) = 0xdb8e209d0cce025a; ++ *((unsigned long *)&__m256i_result3) = 0x88888a6d0962002e; ++ *((unsigned long *)&__m256i_result2) = 0xdb8a3109fe0f0020; ++ *((unsigned long *)&__m256i_result1) = 0x0000007fff01fffb; ++ *((unsigned long *)&__m256i_result0) = 0xdb8e20990cce025a; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0x88); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000002b902b3e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000002b902b3e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000002a102a3a; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000002a102a3a; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0xd9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op02) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op00) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op13) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op12) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op10) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000090909090; ++ *((unsigned long *)&__m256i_result2) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result1) = 0x0000000090909090; ++ *((unsigned long *)&__m256i_result0) = 0x9090909090909090; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0x95); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_op02) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_op01) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_op00) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x4545454545454545; ++ *((unsigned long *)&__m256i_result2) = 0x4545454545454545; ++ *((unsigned long *)&__m256i_result1) = 0x4545454545454545; ++ *((unsigned long *)&__m256i_result0) = 0x4545454545454545; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0x4d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op02) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op01) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op00) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op13) = 0x21bb481000ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x01bf481000000000; ++ *((unsigned long *)&__m256i_op11) = 0x21bb481000ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x01bf481000000000; ++ *((unsigned long *)&__m256i_result3) = 0xb1b3b1b1b1b7b1b1; ++ *((unsigned long *)&__m256i_result2) = 0xb1b7b1b1b1b1b1b1; ++ *((unsigned long *)&__m256i_result1) = 0xb1b3b1b1b1b7b1b1; ++ *((unsigned long *)&__m256i_result0) = 0xb1b7b1b1b1b1b1b1; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0xb7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op02) = 0xc03fc03fc03fc03f; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op00) = 0xc03fc03fc03fc03f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000002d; ++ *((unsigned long *)&__m256i_result2) = 0xc02dc02dc02dc02d; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000002d; ++ *((unsigned long *)&__m256i_result0) = 0xc02dc02dc02dc02d; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0xed); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x60600000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x6060000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x60600000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x6060000000000000; ++ __m256i_out = __lasx_xvbitseli_b (__m256i_op0, __m256i_op1, 0x60); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitset.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitset.c +new file mode 100644 +index 000000000..c195cd91c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitset.c +@@ -0,0 +1,620 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff000000010000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000095120000; ++ *((unsigned long *)&__m256i_op01) = 0xc9da000063f50000; ++ *((unsigned long *)&__m256i_op00) = 0xc7387fff6bbfffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffdffffffc81aca; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff3a0b9512; ++ *((unsigned long *)&__m256i_op11) = 0x280bc9db313a63f5; ++ *((unsigned long *)&__m256i_op10) = 0xe032c738adcb6bbb; ++ *((unsigned long *)&__m256i_result3) = 0xffff800001010400; ++ *((unsigned long *)&__m256i_result2) = 0x000180009d120004; ++ *((unsigned long *)&__m256i_result1) = 0xc9da080067f50020; ++ *((unsigned long *)&__m256i_result0) = 0xc73c7fff6bbfffff; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffff8046867f79; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffff328dfff; ++ *((unsigned long *)&__m256i_op10) = 0x6651bfff80000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00010001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00010001; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000040000fff8; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00001f41ffffbf00; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x010180068080fff9; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x3ff1808001020101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x3ff1808001020101; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0800000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000102; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010103; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x8000000040000000; ++ *((unsigned long *)&__m256i_result2) = 0x4000000010000010; ++ *((unsigned long *)&__m256i_result1) = 0x8000000040000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000040000010; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbea2e127c046721f; ++ *((unsigned long *)&__m256i_op02) = 0x1729c073816edebe; ++ *((unsigned long *)&__m256i_op01) = 0xde91f010000006f9; ++ *((unsigned long *)&__m256i_op00) = 0x5ef1f90efefaf30d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000060000108; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001060005; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fef0001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xbfa3e127c147721f; ++ *((unsigned long *)&__m256i_result2) = 0x1729c173836edfbe; ++ *((unsigned long *)&__m256i_result1) = 0xdf91f111808007fb; ++ *((unsigned long *)&__m256i_result0) = 0x5ff1f90ffffbf30f; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op02) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op01) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op00) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_result2) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_result1) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_result0) = 0xe161616161614f61; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op02) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x01010101010000ff; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x8080808280808082; ++ *((unsigned long *)&__m256i_result2) = 0x8080808280808082; ++ *((unsigned long *)&__m256i_result1) = 0x8080808280808080; ++ *((unsigned long *)&__m256i_result0) = 0x8080808280808082; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000082f8989a; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000d58f43c8; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010183f9999b; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x01010101d58f43c9; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op02) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_op01) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op00) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ffe7ffd7ffe7fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ffe7ffd7ffe8001; ++ *((unsigned long *)&__m256i_result3) = 0x0707feb70707b7d1; ++ *((unsigned long *)&__m256i_result2) = 0x65baa7efea95a985; ++ *((unsigned long *)&__m256i_result1) = 0x0707feb70707b7d1; ++ *((unsigned long *)&__m256i_result0) = 0x65baa7ef6a95a987; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x41cc5bb8a95fd1eb; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x41cc5bb8a95fd1eb; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7b7b7b7b80000000; ++ *((unsigned long *)&__m256i_op12) = 0xcacacb1011040500; ++ *((unsigned long *)&__m256i_op11) = 0x7b7b7b7b80000000; ++ *((unsigned long *)&__m256i_op10) = 0xcacacb1011040500; ++ *((unsigned long *)&__m256i_result3) = 0x49cc5bb8a95fd1eb; ++ *((unsigned long *)&__m256i_result2) = 0x7ff4080102102001; ++ *((unsigned long *)&__m256i_result1) = 0x49cc5bb8a95fd1eb; ++ *((unsigned long *)&__m256i_result0) = 0x7ff4080102102001; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010401; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010401; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010401; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010401; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op02) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_op01) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op00) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_op13) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0xdf01010153a10101; ++ *((unsigned long *)&__m256i_result2) = 0x5b7f01ff5b7f10ff; ++ *((unsigned long *)&__m256i_result1) = 0xdf01010153a10101; ++ *((unsigned long *)&__m256i_result0) = 0x5b7f01ff5b7f10ff; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op12) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_op11) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op10) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_result3) = 0x0000080000001000; ++ *((unsigned long *)&__m256i_result2) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result1) = 0x0000080000001000; ++ *((unsigned long *)&__m256i_result0) = 0x0000080000000800; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_op02) = 0x23222120171e151c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_op00) = 0x23222120171e151c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x201fdfe0201fdfe0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x201fdfe0201fdfe0; ++ *((unsigned long *)&__m256i_result3) = 0x0101010127272525; ++ *((unsigned long *)&__m256i_result2) = 0x23a2a121179e951d; ++ *((unsigned long *)&__m256i_result1) = 0x0101010127272525; ++ *((unsigned long *)&__m256i_result0) = 0x23a2a121179e951d; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op13) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x800080008000ffee; ++ *((unsigned long *)&__m256i_result2) = 0x800080008000ffee; ++ *((unsigned long *)&__m256i_result1) = 0x800080008000ffee; ++ *((unsigned long *)&__m256i_result0) = 0x800080008000ffee; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000100010001ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000100010001ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000100010001ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000100010001ffff; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x00010000fffe0000; ++ *((unsigned long *)&__m256i_op12) = 0x00010000fffe0000; ++ *((unsigned long *)&__m256i_op11) = 0x00010000fffe0000; ++ *((unsigned long *)&__m256i_op10) = 0x00010000fffe0000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x01010101010101c9; ++ __m256i_out = __lasx_xvbitset_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000affff800b; ++ *((unsigned long *)&__m256i_op12) = 0x0000000affff800b; ++ *((unsigned long *)&__m256i_op11) = 0x0000000affff800b; ++ *((unsigned long *)&__m256i_op10) = 0x0000000affff800b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000800; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000400010004; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000400010004; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000f0001000f; ++ *((unsigned long *)&__m256i_result2) = 0x0001000f0001000d; ++ *((unsigned long *)&__m256i_result1) = 0x0001000f0001000f; ++ *((unsigned long *)&__m256i_result0) = 0x0001000f0001000d; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f010000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f010000000100; ++ *((unsigned long *)&__m256i_op13) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x007f010100000101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x007f010100000101; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvbitset_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op02) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op01) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op00) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x498100814843ffe1; ++ *((unsigned long *)&__m256i_result2) = 0x4981008168410001; ++ *((unsigned long *)&__m256i_result1) = 0x498100814843ffe1; ++ *((unsigned long *)&__m256i_result0) = 0x4981008168410001; ++ __m256i_out = __lasx_xvbitset_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000090b0906; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100002000; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op02) = 0x03acfc5303260e80; ++ *((unsigned long *)&__m256i_op01) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op00) = 0x03acfc5303260e80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_result3) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_result2) = 0x03acfc5303260e81; ++ *((unsigned long *)&__m256i_result1) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_result0) = 0x03acfc5303260e81; ++ __m256i_out = __lasx_xvbitset_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseti.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseti.c +new file mode 100644 +index 000000000..47f37e4b3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvbitseti.c +@@ -0,0 +1,405 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffcf800fffcf800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result2) = 0xfffcf800fffcf800; ++ *((unsigned long *)&__m256i_result1) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result0) = 0x0000080000000800; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00007f7f00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00007f7f00007fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000040000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007f7f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000040000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007f7f00007fff; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_result2) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_result1) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_result0) = 0x0202020202020202; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000800000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800000000; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result2) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result1) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result0) = 0x1010101010101010; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000004000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000004000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000004000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000004000000; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000013; ++ *((unsigned long *)&__m256i_op02) = 0x00000001000000fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000013; ++ *((unsigned long *)&__m256i_op00) = 0x00000001000000fb; ++ *((unsigned long *)&__m256i_result3) = 0x8080808180808093; ++ *((unsigned long *)&__m256i_result2) = 0x80808081808080fe; ++ *((unsigned long *)&__m256i_result1) = 0x8080808180808093; ++ *((unsigned long *)&__m256i_result0) = 0x80808081808080fb; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000020; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result2) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result1) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result0) = 0x0010000000100000; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100010; ++ __m256i_out = __lasx_xvbitseti_h (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op02) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op01) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op00) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_result3) = 0x1000100054445443; ++ *((unsigned long *)&__m256i_result2) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_result1) = 0x1000100054445443; ++ *((unsigned long *)&__m256i_result0) = 0x7bbbbbbbf7777778; ++ __m256i_out = __lasx_xvbitseti_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000200; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffa2078fffa2074; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffa2078fffa2074; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result2) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result0) = 0xfffeffebfb7afb62; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_op02) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_op01) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_op00) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result3) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result2) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result1) = 0xe7e7e7e7e7e7e7e7; ++ *((unsigned long *)&__m256i_result0) = 0xe7e7e7e7e7e7e7e7; ++ __m256i_out = __lasx_xvbitseti_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020206431; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0003030300000300; ++ *((unsigned long *)&__m256i_op02) = 0x0003030300000300; ++ *((unsigned long *)&__m256i_op01) = 0x0003030300000100; ++ *((unsigned long *)&__m256i_op00) = 0x0003030300000100; ++ *((unsigned long *)&__m256i_result3) = 0x0043030300400300; ++ *((unsigned long *)&__m256i_result2) = 0x0043030300400300; ++ *((unsigned long *)&__m256i_result1) = 0x0043030300400100; ++ *((unsigned long *)&__m256i_result0) = 0x0043030300400100; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x223d76f09f3881ff; ++ *((unsigned long *)&__m256i_op02) = 0x3870ca8d013e76a0; ++ *((unsigned long *)&__m256i_op01) = 0x223d76f09f37e357; ++ *((unsigned long *)&__m256i_op00) = 0x43ec0a1b2aba7ed0; ++ *((unsigned long *)&__m256i_result3) = 0x223d76f09f3881ff; ++ *((unsigned long *)&__m256i_result2) = 0x3870ca9d013e76b0; ++ *((unsigned long *)&__m256i_result1) = 0x223d76f09f37e357; ++ *((unsigned long *)&__m256i_result0) = 0x43ec0a1b2aba7ed0; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f8f7f8f800f800; ++ *((unsigned long *)&__m256i_op02) = 0x00003f780000ff80; ++ *((unsigned long *)&__m256i_op01) = 0xf7f8f7f80000fff9; ++ *((unsigned long *)&__m256i_op00) = 0x00003f780000ff80; ++ *((unsigned long *)&__m256i_result3) = 0xf7f8f7f8f800f800; ++ *((unsigned long *)&__m256i_result2) = 0x00003f784000ff80; ++ *((unsigned long *)&__m256i_result1) = 0xf7f8f7f84000fff9; ++ *((unsigned long *)&__m256i_result0) = 0x00003f784000ff80; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result2) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result0) = 0x4040404040404040; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op02) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op01) = 0x00ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op00) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result3) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result2) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result1) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result0) = 0xffe1ffe0ffe1ffe0; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffefef800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffefef800; ++ *((unsigned long *)&__m256i_result3) = 0x0000008000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffefef800; ++ *((unsigned long *)&__m256i_result1) = 0x0000008000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffefef800; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x27); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_result2) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_result1) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_result0) = 0x0002000000020000; ++ __m256i_out = __lasx_xvbitseti_w (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_result3) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result2) = 0x00020002000230ba; ++ *((unsigned long *)&__m256i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result0) = 0x00020002000230ba; ++ __m256i_out = __lasx_xvbitseti_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result2) = 0x8100810081008100; ++ *((unsigned long *)&__m256i_result1) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result0) = 0x8100810081008100; ++ __m256i_out = __lasx_xvbitseti_h (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007878; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000007878; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000107878; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000107878; ++ __m256i_out = __lasx_xvbitseti_h (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256i_result3) = 0x4000400140004001; ++ *((unsigned long *)&__m256i_result2) = 0xfffff2f640006f48; ++ *((unsigned long *)&__m256i_result1) = 0x4000400140004001; ++ *((unsigned long *)&__m256i_result0) = 0xfffff2f640006f48; ++ __m256i_out = __lasx_xvbitseti_h (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvbitseti_d (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x4040404040404040; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op02) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op01) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op00) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_result3) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_result2) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_result1) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_result0) = 0xfd12fd12fd12fd12; ++ __m256i_out = __lasx_xvbitseti_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclo.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclo.c +new file mode 100644 +index 000000000..dbc52f92b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclo.c +@@ -0,0 +1,449 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffd1b24e00000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffcea54ffff29a8; ++ *((unsigned long *)&__m256i_op01) = 0xff8cad88ff8306b4; ++ *((unsigned long *)&__m256i_op00) = 0xfffc1278fffce4c8; ++ *((unsigned long *)&__m256i_result3) = 0x0802010000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0806030008080001; ++ *((unsigned long *)&__m256i_result1) = 0x0801010108010001; ++ *((unsigned long *)&__m256i_result0) = 0x0806000008060302; ++ __m256i_out = __lasx_xvclo_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfafafafafafafafa; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000fefefe; ++ *((unsigned long *)&__m256i_result3) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100010; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op02) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op01) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op00) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0fff0fff00000020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0fff0fff00000020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvclo_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_op02) = 0x01fc03fc01fc03fc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_op00) = 0x01fc03fc01fc03fc; ++ *((unsigned long *)&__m256i_result3) = 0x000000200000001e; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000200000001e; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000808; ++ __m256i_out = __lasx_xvclo_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xd04752cdd5543b56; ++ *((unsigned long *)&__m256i_op02) = 0x6906e68064f3d78b; ++ *((unsigned long *)&__m256i_op01) = 0xd04752cdd5543b56; ++ *((unsigned long *)&__m256i_op00) = 0x6906e68064f3d78b; ++ *((unsigned long *)&__m256i_result3) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000300000002; ++ *((unsigned long *)&__m256i_result1) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000300000002; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc0000000c0000000; ++ *((unsigned long *)&__m256i_op02) = 0xc000000080400000; ++ *((unsigned long *)&__m256i_op01) = 0xc0000000c0000000; ++ *((unsigned long *)&__m256i_op00) = 0xc000000080400000; ++ *((unsigned long *)&__m256i_result3) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_result2) = 0x0002000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_result0) = 0x0002000000010000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0010000100000000; ++ *((unsigned long *)&__m256i_result1) = 0x0010000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0010000100000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000004000000020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000004000000020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000201220001011c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000201220001011c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100010; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000100010; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclo_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclz.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclz.c +new file mode 100644 +index 000000000..89191c467 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvclz.c +@@ -0,0 +1,504 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x04481940fbb7e6bf; ++ *((unsigned long *)&__m256i_op02) = 0xf2781966e6991966; ++ *((unsigned long *)&__m256i_op01) = 0x51258839aeda77c6; ++ *((unsigned long *)&__m256i_op00) = 0xcf25f0e00f1ff0e0; ++ *((unsigned long *)&__m256i_result3) = 0x0501030100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001030100000301; ++ *((unsigned long *)&__m256i_result1) = 0x0102000200000100; ++ *((unsigned long *)&__m256i_result0) = 0x0002000004030000; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000f0000000f; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000003868686a20; ++ *((unsigned long *)&__m256i_op02) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_op01) = 0x0000003868686a20; ++ *((unsigned long *)&__m256i_op00) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_result3) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000900000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000900000000; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100010; ++ __m256i_out = __lasx_xvclz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080807; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080807; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100001; ++ __m256i_out = __lasx_xvclz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0008000000080000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0008000000080000; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000100010; ++ __m256i_out = __lasx_xvclz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000018; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000019; ++ *((unsigned long *)&__m256i_result1) = 0x000000200000001e; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000019; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0b085bfc00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0b004bc000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0b085bfc00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0b004bc000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0404010008080808; ++ *((unsigned long *)&__m256i_result2) = 0x0408010008080808; ++ *((unsigned long *)&__m256i_result1) = 0x0404010008080808; ++ *((unsigned long *)&__m256i_result0) = 0x0408010008080808; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op02) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op01) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op00) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000012; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0404010008080808; ++ *((unsigned long *)&__m256i_op02) = 0x0408010008080808; ++ *((unsigned long *)&__m256i_op01) = 0x0404010008080808; ++ *((unsigned long *)&__m256i_op00) = 0x0408010008080808; ++ *((unsigned long *)&__m256i_result3) = 0x0505070804040404; ++ *((unsigned long *)&__m256i_result2) = 0x0504070804040404; ++ *((unsigned long *)&__m256i_result1) = 0x0505070804040404; ++ *((unsigned long *)&__m256i_result0) = 0x0504070804040404; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006ffff0004ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0002ffff0000ff00; ++ *((unsigned long *)&__m256i_op01) = 0x0006ffff0004ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0002ffff0000ff00; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000000d; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000e; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000000d; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000e; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000032; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000003c000000032; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result2) = 0x001000100010000a; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result0) = 0x001000060010000a; ++ __m256i_out = __lasx_xvclz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op02) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_op01) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op00) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000000e; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000000e; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000c; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0000000008080800; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0000000008080800; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op02) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op00) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0004001000100004; ++ *((unsigned long *)&__m256i_result2) = 0x0004000400100010; ++ *((unsigned long *)&__m256i_result1) = 0x0004001000100004; ++ *((unsigned long *)&__m256i_result0) = 0x0004000400100010; ++ __m256i_out = __lasx_xvclz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000020; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007f8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000007f8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000029; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000029; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvclz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000027; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvclz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvclz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpcnt.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpcnt.c +new file mode 100644 +index 000000000..d2e742e81 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpcnt.c +@@ -0,0 +1,526 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x639c3fffb5dffffe; ++ *((unsigned long *)&__m256i_op00) = 0xb8c7800094400001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0008000e000c000f; ++ *((unsigned long *)&__m256i_result0) = 0x0009000100040001; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op02) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op01) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op00) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_result3) = 0x0004000400040805; ++ *((unsigned long *)&__m256i_result2) = 0x0004000400040805; ++ *((unsigned long *)&__m256i_result1) = 0x0004000400040805; ++ *((unsigned long *)&__m256i_result0) = 0x0004000400040805; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op02) = 0xfffcf800fffcf800; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result3) = 0x0008000800000003; ++ *((unsigned long *)&__m256i_result2) = 0x0806050008060500; ++ *((unsigned long *)&__m256i_result1) = 0x0008000800000003; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000000100; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002e2100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000040002; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x34000000fff00000; ++ *((unsigned long *)&__m256i_op02) = 0xfff6e00000000000; ++ *((unsigned long *)&__m256i_op01) = 0x3380000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x363c0000fff3c000; ++ *((unsigned long *)&__m256i_result3) = 0x000000030000000c; ++ *((unsigned long *)&__m256i_result2) = 0x0000001100000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000500000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800000010; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00c100c100c100c1; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00c100c100c100c1; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_result1) = 0x0000080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0000080800000808; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808080808; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256i_op02) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256i_op00) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_result2) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_result0) = 0x0100000100000001; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000020; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000001555; ++ *((unsigned long *)&__m256i_op02) = 0x000015554001c003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000001555; ++ *((unsigned long *)&__m256i_op00) = 0x000015554001c003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000304; ++ *((unsigned long *)&__m256i_result2) = 0x0000030401010202; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000304; ++ *((unsigned long *)&__m256i_result0) = 0x0000030401010202; ++ __m256i_out = __lasx_xvpcnt_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000a0008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000a0008; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_result3) = 0x0010001000030000; ++ *((unsigned long *)&__m256i_result2) = 0x0010001000030000; ++ *((unsigned long *)&__m256i_result1) = 0x0010001000030000; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000030000; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op02) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_op01) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op00) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000008; ++ *((unsigned long *)&__m256i_result2) = 0x000000040000001b; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000008; ++ *((unsigned long *)&__m256i_result0) = 0x000000040000001b; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000b000b000b000b; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000b000b000b000b; ++ __m256i_out = __lasx_xvpcnt_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000001f00000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000001f00000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op01) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_result2) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_result1) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_result0) = 0x0000001200000012; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op02) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op01) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op00) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvpcnt_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvext2xv-xvexth-x.patch
Added
@@ -0,0 +1,4600 @@ +From 5cf957f25df755431bc77845fecb5bec0624c097 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:51:19 +0800 +Subject: PATCH 118/124 LoongArch: Add tests for ASX vector + xvext2xv/xvexth/xvextins/xvilvh/xvilvl/xvinsgr2vr/ xvinsve0/xvprem/xvpremi + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvext2xv-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvext2xv-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvexth-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvexth-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvextrins.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvilvh.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvilvl.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvinsgr2vr.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvinsve0.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvprem.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvpremi.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvext2xv-1.c | 515 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvext2xv-2.c | 669 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvexth-1.c | 350 +++++++++ + .../loongarch/vector/lasx/lasx-xvexth-2.c | 592 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvextrins.c | 515 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvilvh.c | 530 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvilvl.c | 620 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvinsgr2vr.c | 272 +++++++ + .../loongarch/vector/lasx/lasx-xvinsve0.c | 380 ++++++++++ + .../loongarch/vector/lasx/lasx-xvprem.c | 20 + + .../loongarch/vector/lasx/lasx-xvpremi.c | 20 + + 11 files changed, 4483 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextrins.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvh.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvl.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsgr2vr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsve0.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvprem.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpremi.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-1.c +new file mode 100644 +index 000000000..94f31019c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-1.c +@@ -0,0 +1,515 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2b2b2b2b1bd5d5d6; ++ *((unsigned long *)&__m256i_op02) = 0x2a2a2a2af2d5d5d6; ++ *((unsigned long *)&__m256i_op01) = 0x2b2b2b2b1bd5d5d6; ++ *((unsigned long *)&__m256i_op00) = 0x2a2a2a2af2d5d5d6; ++ *((unsigned long *)&__m256i_result3) = 0x0000002a0000002a; ++ *((unsigned long *)&__m256i_result2) = 0x0000002a0000002a; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff2ffffffd5; ++ *((unsigned long *)&__m256i_result0) = 0xffffffd5ffffffd6; ++ __m256i_out = __lasx_vext2xv_w_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_w_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0xfff0fff0fff0fff0; ++ *((unsigned long *)&__m256i_op01) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0xfff0fff0fff0fff0; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff0; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_d_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fe; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000017f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000017f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000017f; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ffffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff00fff0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffff00fffffff0; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffe20; ++ *((unsigned long *)&__m256i_result2) = 0x0000001dfffffe1f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0200000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x2000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0200000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x2000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000020000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op02) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op01) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op00) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result3) = 0x0000498000000080; ++ *((unsigned long *)&__m256i_result2) = 0x00004843ffffffe0; ++ *((unsigned long *)&__m256i_result1) = 0x0000498000000080; ++ *((unsigned long *)&__m256i_result0) = 0x0000684000000000; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op02) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op00) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000017; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00020002ff820002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00020002ff820002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffff82; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x03fbfffc03fc07fc; ++ *((unsigned long *)&__m256i_op02) = 0x8000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x03fbfffc03fc07fc; ++ *((unsigned long *)&__m256i_op00) = 0x8000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_d_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xd100645944100004; ++ *((unsigned long *)&__m256i_op02) = 0xd1908469108400d1; ++ *((unsigned long *)&__m256i_op01) = 0x0000000404040104; ++ *((unsigned long *)&__m256i_op00) = 0xd1108199714910f9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000004040104; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffd1108199; ++ *((unsigned long *)&__m256i_result0) = 0x00000000714910f9; ++ __m256i_out = __lasx_vext2xv_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_vext2xv_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-2.c +new file mode 100644 +index 000000000..d93201bc4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvext2xv-2.c +@@ -0,0 +1,669 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x639c3fffb5dffffe; ++ *((unsigned long *)&__m256i_op00) = 0xb8c7800094400001; ++ *((unsigned long *)&__m256i_result3) = 0x0063009c003f00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00b500df00ff00fe; ++ *((unsigned long *)&__m256i_result1) = 0x00b800c700800000; ++ *((unsigned long *)&__m256i_result0) = 0x0094004000000001; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00aa00ab00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00aa00ab00ff00ff; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x01ff01ff01c0003e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x01ff01ff01c0003e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000100ff000100ff; ++ *((unsigned long *)&__m256i_result0) = 0x000100c00000003e; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000f0001000f; ++ *((unsigned long *)&__m256i_op02) = 0x0001000f0001000d; ++ *((unsigned long *)&__m256i_op01) = 0x0001000f0001000f; ++ *((unsigned long *)&__m256i_op00) = 0x0001000f0001000d; ++ *((unsigned long *)&__m256i_result3) = 0x000000010000000f; ++ *((unsigned long *)&__m256i_result2) = 0x000000010000000f; ++ *((unsigned long *)&__m256i_result1) = 0x000000010000000f; ++ *((unsigned long *)&__m256i_result0) = 0x000000010000000d; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000080; ++ __m256i_out = __lasx_vext2xv_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6100000800060005; ++ *((unsigned long *)&__m256i_op02) = 0x5ee1c073b800c916; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5ff00007fff9fff3; ++ *((unsigned long *)&__m256i_result3) = 0x0000005f000000f0; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000f9; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000f3; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000781; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000064; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000029; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000029; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000029; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_vext2xv_wu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffffefd; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffefd; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fd; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff7fff7f; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff7f027f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff7f0100; ++ *((unsigned long *)&__m256i_op00) = 0xff00fe00fe7f027f; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000007f; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000ff; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000003fbfc04; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001fdfe02; ++ *((unsigned long *)&__m256i_op01) = 0x0000000003fbfc04; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001fdfe02; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000fd; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ef; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000080; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op02) = 0x0000002e0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op00) = 0x0000002e0000fffe; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000002e; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000002e; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000002e; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000fffe; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffcfee0fe00ffe0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffcfee0fe00ffe0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffc0000fee0; ++ *((unsigned long *)&__m256i_result0) = 0x0000fe000000ffe0; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_op02) = 0x0000001b00fd0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_op00) = 0x0000001b00fd0000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000001b; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000001b; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000001b; ++ *((unsigned long *)&__m256i_result0) = 0x000000fd00000000; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000017f7f7f; ++ *((unsigned long *)&__m256i_op02) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000017f7f7f; ++ *((unsigned long *)&__m256i_op00) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000017f00007f7f; ++ *((unsigned long *)&__m256i_result1) = 0x00007f0000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff0000ff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff0000ff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff00000000ff; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op02) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op01) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op00) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result3) = 0x0000498000000080; ++ *((unsigned long *)&__m256i_result2) = 0x000048430000ffe0; ++ *((unsigned long *)&__m256i_result1) = 0x0000498000000080; ++ *((unsigned long *)&__m256i_result0) = 0x0000684000000000; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff7eddffff7ed3; ++ *((unsigned long *)&__m256i_op02) = 0xffff7edfffff7edf; ++ *((unsigned long *)&__m256i_op01) = 0xffff7eddffff7ed3; ++ *((unsigned long *)&__m256i_op00) = 0xffff7edfffff7edf; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00007edd; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00007ed3; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00007edf; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00007edf; ++ __m256i_out = __lasx_vext2xv_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000801380f380fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000801380f300fb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000008013; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000080f3; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fb; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000008000; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000007f; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_vext2xv_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-1.c +new file mode 100644 +index 000000000..9fb4e3ff0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-1.c +@@ -0,0 +1,350 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op02) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op01) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op00) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result3) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_result2) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_result1) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_result0) = 0x005500550055ffab; ++ __m256i_out = __lasx_xvexth_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff010ff0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff010ff0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_h_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffec; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffebd8; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffec; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffebd8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffec; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffec; ++ __m256i_out = __lasx_xvexth_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvexth_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0xffffff1cffffff1c; ++ *((unsigned long *)&__m256i_result2) = 0xffffff1cffffff1c; ++ *((unsigned long *)&__m256i_result1) = 0xffffff1cffffff1c; ++ *((unsigned long *)&__m256i_result0) = 0xffffff1cffffff1c; ++ __m256i_out = __lasx_xvexth_w_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001010101; ++ __m256i_out = __lasx_xvexth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvexth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000010; ++ __m256i_out = __lasx_xvexth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvexth_d_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000007f00340040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000007f000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffec; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffec; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00080000002c0000; ++ *((unsigned long *)&__m256i_op02) = 0x0008000000080000; ++ *((unsigned long *)&__m256i_op01) = 0x00080000002c0000; ++ *((unsigned long *)&__m256i_op00) = 0x0008000000080000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00080000002c0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00080000002c0000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-2.c +new file mode 100644 +index 000000000..fe6ff15d8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvexth-2.c +@@ -0,0 +1,592 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000045f3fb; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000000045f3fb; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000004500f300fb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000004500f300fb; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op02) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_op01) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op00) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_result3) = 0x004100df00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00c000000000; ++ *((unsigned long *)&__m256i_result1) = 0x004100df00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00c000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result2) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result1) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result0) = 0x007f00ff007f00ff; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op02) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op01) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op00) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result3) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_result2) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_result1) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_result0) = 0x0002000200010002; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00ff00ff; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0080000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0080000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_hu_bu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffff8046867f79; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffff328dfff; ++ *((unsigned long *)&__m256i_op00) = 0x6651bfff80000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256i_result2) = 0x0000468600007f79; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000f3280000dfff; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000fffe; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffa30000165a; ++ *((unsigned long *)&__m256i_op02) = 0x0000104000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffa30000165a; ++ *((unsigned long *)&__m256i_op00) = 0x0000104000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000165a; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001010600000106; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001010600000106; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007cfcfd80000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007cfcfd80000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000002000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000020ff790020; ++ *((unsigned long *)&__m256i_op01) = 0x0000002000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000020ff790020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001ff03fe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffec75c2d209f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001ff03fe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffec75c2d209f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000001ff000003fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000001ff000003fe; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_result2) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_result1) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_result0) = 0x0000010100000101; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000ff; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvexth_wu_hu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_du_wu (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_op02) = 0x00d6c1c830160048; ++ *((unsigned long *)&__m256i_op01) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_op00) = 0xe3aebaf4df958004; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x36722a7e66972cd6; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff5f5c; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000102; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000102; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op02) = 0x000000a400ff004f; ++ *((unsigned long *)&__m256i_op01) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op00) = 0x000000a400ff004f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000010000005e; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff0000; ++ __m256i_out = __lasx_xvexth_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextrins.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextrins.c +new file mode 100644 +index 000000000..8e61f1c6d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextrins.c +@@ -0,0 +1,515 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000020202; ++ *((unsigned long *)&__m256i_op12) = 0x0000000002020202; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000020200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfe02fe02fee5fe22; ++ *((unsigned long *)&__m256i_op00) = 0xff49fe4200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0xbf28b0686066be60; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0xff49fe4200000000; ++ __m256i_out = __lasx_xvextrins_d (__m256i_op0, __m256i_op1, 0xbf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result3) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result1) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fe; ++ __m256i_out = __lasx_xvextrins_b (__m256i_op0, __m256i_op1, 0xfe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_d (__m256i_op0, __m256i_op1, 0x9f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_d (__m256i_op0, __m256i_op1, 0xc4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvextrins_d (__m256i_op0, __m256i_op1, 0x99); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000fffffefc0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000fffffffe0; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000fffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000fffffffff; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x8f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op12) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op11) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op10) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000061; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000061; ++ __m256i_out = __lasx_xvextrins_b (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0x83); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op12) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op11) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op10) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007bbbbbbb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007bbbbbbb; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x8d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x66); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0xda); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff900000800; ++ *((unsigned long *)&__m256i_result3) = 0x00007f7f00007f00; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00007f7f00007fff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_b (__m256i_op0, __m256i_op1, 0x87); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0xa5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2b2a292827262524; ++ *((unsigned long *)&__m256i_op02) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_op01) = 0x2b2a292827262524; ++ *((unsigned long *)&__m256i_op00) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_result3) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_result2) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000027262524; ++ *((unsigned long *)&__m256i_result0) = 0x232221201f1e1d1c; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0xbd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000080000000; ++ __m256i_out = __lasx_xvextrins_b (__m256i_op0, __m256i_op1, 0x33); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_d (__m256i_op0, __m256i_op1, 0xb8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff0000; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x54); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_b (__m256i_op0, __m256i_op1, 0xe7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x7e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op02) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op00) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result2) = 0xff00010001000100; ++ *((unsigned long *)&__m256i_result1) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result0) = 0xff00010001000100; ++ __m256i_out = __lasx_xvextrins_b (__m256i_op0, __m256i_op1, 0x7b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_d (__m256i_op0, __m256i_op1, 0x56); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op01) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff01; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0x6f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op13) = 0x8000000001010100; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000405; ++ *((unsigned long *)&__m256i_op11) = 0x8000000001010100; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000405; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000600000006; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0xf6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000007f8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000007f8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0x7b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_op02) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_op00) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_op13) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_op12) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_op10) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff00fff8ffc0; ++ __m256i_out = __lasx_xvextrins_b (__m256i_op0, __m256i_op1, 0x82); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000002000000; ++ __m256i_out = __lasx_xvextrins_h (__m256i_op0, __m256i_op1, 0x43); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextrins_d (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256i_op12) = 0xfffe97a1df5b41b0; ++ *((unsigned long *)&__m256i_op11) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256i_op10) = 0xfffe97a1df5b41b0; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff007ffd61; ++ *((unsigned long *)&__m256i_result2) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff007ffd61; ++ *((unsigned long *)&__m256i_result0) = 0xfffe97c020010001; ++ __m256i_out = __lasx_xvextrins_w (__m256i_op0, __m256i_op1, 0x62); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvh.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvh.c +new file mode 100644 +index 000000000..5a047a508 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvh.c +@@ -0,0 +1,530 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xbff0800000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xbff0800000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffff90ffffff81; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffff90ffffff81; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000307fffe72e800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020200008; ++ *((unsigned long *)&__m256i_op01) = 0x0008010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_result2) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_result1) = 0x0008000001010000; ++ *((unsigned long *)&__m256i_result0) = 0x0101000001010000; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op13) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_op12) = 0x5555555580000000; ++ *((unsigned long *)&__m256i_op11) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_op10) = 0x5555555580000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x555555553f800000; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000003f00000000; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_op02) = 0x2475cef801f0ffdd; ++ *((unsigned long *)&__m256i_op01) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_op00) = 0x419cd5b11c3c5654; ++ *((unsigned long *)&__m256i_op13) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_op12) = 0x2475cef801f0ffdd; ++ *((unsigned long *)&__m256i_op11) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_op10) = 0x419cd5b11c3c5654; ++ *((unsigned long *)&__m256i_result3) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_result2) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_result1) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_result0) = 0x6580668200fe0002; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xf5f5f5f5f5f5f5f5; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xf5f5f5f5f5f5f5f5; ++ *((unsigned long *)&__m256i_op13) = 0x0000000004000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000004000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result2) = 0xff04ff00ff00ff00; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result0) = 0xff04ff00ff00ff00; ++ __m256i_out = __lasx_xvilvh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000003f00390035; ++ *((unsigned long *)&__m256i_op02) = 0x8015003f0006001f; ++ *((unsigned long *)&__m256i_op01) = 0x0000003f00390035; ++ *((unsigned long *)&__m256i_op00) = 0x8015003f0006001f; ++ *((unsigned long *)&__m256i_op13) = 0x80000000001529c1; ++ *((unsigned long *)&__m256i_op12) = 0x80007073cadc3779; ++ *((unsigned long *)&__m256i_op11) = 0x80000000001529c1; ++ *((unsigned long *)&__m256i_op10) = 0x80007073cadc3779; ++ *((unsigned long *)&__m256i_result3) = 0x00008000003f0000; ++ *((unsigned long *)&__m256i_result2) = 0x00390015003529c1; ++ *((unsigned long *)&__m256i_result1) = 0x00008000003f0000; ++ *((unsigned long *)&__m256i_result0) = 0x00390015003529c1; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0020002000200020; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000002c; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000002c; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000002c; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000002c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000002c0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000002c0000; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7eeefefefefefefe; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x7eeefefefefefefe; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7e00ee00fe00fe00; ++ *((unsigned long *)&__m256i_result2) = 0xfe00fe00fe00fe00; ++ *((unsigned long *)&__m256i_result1) = 0x7e00ee00fe00fe00; ++ *((unsigned long *)&__m256i_result0) = 0xfe00fe00fe00fe00; ++ __m256i_out = __lasx_xvilvh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xaad5555500000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xaad5555500000000; ++ *((unsigned long *)&__m256i_op13) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00001fff200007ef; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00001fff200007ef; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff7bfffff1; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff80007fe9; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff7bfffff1; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff80007fe9; ++ *((unsigned long *)&__m256i_result3) = 0x40ff40ff40ff40ff; ++ *((unsigned long *)&__m256i_result2) = 0x407b40ff40ff40f1; ++ *((unsigned long *)&__m256i_result1) = 0x40ff40ff40ff40ff; ++ *((unsigned long *)&__m256i_result0) = 0x407b40ff40ff40f1; ++ __m256i_out = __lasx_xvilvh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff02000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff02000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0001fffa; ++ *((unsigned long *)&__m256i_op02) = 0x0001fffe00018069; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0001fffa; ++ *((unsigned long *)&__m256i_op00) = 0x0001fffe00018069; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00ff01fffffffeff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff01fffffffaff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff01fffffffeff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff01fffffffaff; ++ __m256i_out = __lasx_xvilvh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00001ff8d8d8c000; ++ *((unsigned long *)&__m256i_op02) = 0x00001ff8d8d90000; ++ *((unsigned long *)&__m256i_op01) = 0x00001ff8d8d8c000; ++ *((unsigned long *)&__m256i_op00) = 0x00001ff8d8d90000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_result3) = 0x00001ff800000000; ++ *((unsigned long *)&__m256i_result2) = 0xd8d8c00000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00001ff800000000; ++ *((unsigned long *)&__m256i_result0) = 0xd8d8c00000000000; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op02) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op01) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op00) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op13) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_op12) = 0x00000080c000c080; ++ *((unsigned long *)&__m256i_op11) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_op10) = 0x00000080c000c080; ++ *((unsigned long *)&__m256i_result3) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080ff0080; ++ *((unsigned long *)&__m256i_result1) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080ff0080; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000203ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000203ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001ff03ff; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0x000000019ffdf403; ++ *((unsigned long *)&__m256i_op12) = 0x000000011ffd97c3; ++ *((unsigned long *)&__m256i_op11) = 0x000000019ffdf403; ++ *((unsigned long *)&__m256i_op10) = 0x000000011ffd97c3; ++ *((unsigned long *)&__m256i_result3) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_result2) = 0x000000019ffdf403; ++ *((unsigned long *)&__m256i_result1) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_result0) = 0x000000019ffdf403; ++ __m256i_out = __lasx_xvilvh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffe0ffe000000000; ++ *((unsigned long *)&__m256i_result1) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffe0ffe000000000; ++ __m256i_out = __lasx_xvilvh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvl.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvl.c +new file mode 100644 +index 000000000..4393045c3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvilvl.c +@@ -0,0 +1,620 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000900000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000001a00000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000900000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff0000fffe0000; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000fefc0000; ++ *((unsigned long *)&__m256i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000fffe0000; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefdfffffefd; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007f7f; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000007f7f; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f007f78; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f00007f7f0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x7f00fffb7f78fffc; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8080808080808081; ++ *((unsigned long *)&__m256i_op11) = 0x8080808080808081; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000808000008080; ++ *((unsigned long *)&__m256i_result2) = 0x0000808000008081; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op02) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op00) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00ff01fffffffeff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff01fffffffeff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff01fffffffeff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff01fffffffeff; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op12) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op11) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op10) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x07efefefefefefee; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffffffffffff; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000005; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op12) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op11) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op10) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00f300ff00f3; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00f300ff00f3; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00f300ff00f3; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00f300ff00f3; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00040000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00fe00fe; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00fe00fe; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff0102; ++ *((unsigned long *)&__m256i_op02) = 0x007c000000810081; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff0102; ++ *((unsigned long *)&__m256i_op00) = 0x007c000000810081; ++ *((unsigned long *)&__m256i_op13) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x007c7fff00007fff; ++ *((unsigned long *)&__m256i_result2) = 0x00817fff00810000; ++ *((unsigned long *)&__m256i_result1) = 0x007c7fff00007fff; ++ *((unsigned long *)&__m256i_result0) = 0x00817fff00810000; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000001d001d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001d0000001d; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op02) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000e0e0e0e0; ++ *((unsigned long *)&__m256i_op00) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op13) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op12) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000070007000; ++ *((unsigned long *)&__m256i_op10) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_result3) = 0xe070e000e070e000; ++ *((unsigned long *)&__m256i_result2) = 0xe070e000e070e000; ++ *((unsigned long *)&__m256i_result1) = 0xe070e000e070e000; ++ *((unsigned long *)&__m256i_result0) = 0xe070e000e070e000; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x003f003f003f0040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x003f003f003f0040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x003f003f003f0040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x003f003f003f0040; ++ *((unsigned long *)&__m256i_result3) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_result2) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result1) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_result0) = 0x00003f3f00004040; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffe98; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000064; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000e000e; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op02) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_op01) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op00) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000a0080000b00; ++ *((unsigned long *)&__m256i_result2) = 0x00000a0080000b00; ++ *((unsigned long *)&__m256i_result1) = 0x00000a0080000b00; ++ *((unsigned long *)&__m256i_result0) = 0x00000a0080000b00; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe01fe01fd02fd02; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_op01) = 0xfe01fe01fd02fd02; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3f00c0003f00c000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3f00c0003f00c000; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op01) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op13) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op12) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op11) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op10) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result3) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result2) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result1) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result0) = 0x4980008068400000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xf000f000f000f000; ++ *((unsigned long *)&__m256i_op12) = 0xf000f010f000f010; ++ *((unsigned long *)&__m256i_op11) = 0xf000f000f000f000; ++ *((unsigned long *)&__m256i_op10) = 0xf000f010f000f010; ++ *((unsigned long *)&__m256i_result3) = 0x00f0000000f00010; ++ *((unsigned long *)&__m256i_result2) = 0xfff0ff00fff0ff10; ++ *((unsigned long *)&__m256i_result1) = 0x00f0000000f00010; ++ *((unsigned long *)&__m256i_result0) = 0xfff0ff00fff0ff10; ++ __m256i_out = __lasx_xvilvl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvilvl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffed; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffed; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffed; ++ __m256i_out = __lasx_xvilvl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsgr2vr.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsgr2vr.c +new file mode 100644 +index 000000000..ce28c4857 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsgr2vr.c +@@ -0,0 +1,272 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_op02) = 0x146014141414146e; ++ *((unsigned long *)&__m256i_op01) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_op00) = 0xf19998668e5f4b84; ++ long_op1 = 0x0000007942652524; ++ *((unsigned long *)&__m256i_result3) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_result2) = 0x0000007942652524; ++ *((unsigned long *)&__m256i_result1) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_result0) = 0xf19998668e5f4b84; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0202020201010000; ++ int_op1 = 0x00000045eef14fe8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000eef14fe8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0202020201010000; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x012e2110012e2110; ++ int_op1 = 0x00000000000000ac; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000ac; ++ *((unsigned long *)&__m256i_result0) = 0x012e2110012e2110; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op02) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op00) = 0xff800000ff800000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_result2) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_result1) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_result0) = 0xff80000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff0000ff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff0000ff; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff0000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff0000ff; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe800c000fffeeece; ++ *((unsigned long *)&__m256i_op02) = 0xffff383efffedf0c; ++ *((unsigned long *)&__m256i_op01) = 0xe800c000fffeeece; ++ *((unsigned long *)&__m256i_op00) = 0xffff383efffedf0c; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0xe800c000fffeeece; ++ *((unsigned long *)&__m256i_result2) = 0xffff383e000000ff; ++ *((unsigned long *)&__m256i_result1) = 0xe800c000fffeeece; ++ *((unsigned long *)&__m256i_result0) = 0xffff383efffedf0c; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op02) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_op01) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op00) = 0x0020000000200000; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result2) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_result1) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result2) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_result0) = 0x4040404040404040; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000048; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000048; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000048; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ long_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_op01) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff7fffffff7; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff700000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff7fffffff7; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_d (__m256i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ int_op1 = 0x00000000090b0906; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000090b0906; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d6d6d; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x000000000000001e; ++ *((unsigned long *)&__m256i_result3) = 0x0000001e00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op02) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op01) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op00) = 0xfefefefefefefefe; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000050005; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefefefefefe; ++ __m256i_out = __lasx_xvinsgr2vr_w (__m256i_op0, int_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsve0.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsve0.c +new file mode 100644 +index 000000000..644d2ce4b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvinsve0.c +@@ -0,0 +1,380 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op12) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op11) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op10) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000050005; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffefe00000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000170017; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000170017; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000170017; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000170017; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffefffffffe; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op12) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff000200000000; ++ *((unsigned long *)&__m256i_op01) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff000200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x001f00e0ff800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x001f00e0ff800000; ++ *((unsigned long *)&__m256i_result3) = 0xff80000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff000200000000; ++ *((unsigned long *)&__m256i_result1) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff000200000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op02) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op01) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op00) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op13) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op12) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op11) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op10) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result3) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result2) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result1) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result0) = 0x9090909090909090; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x000040b200002fd4; ++ *((unsigned long *)&__m256i_op12) = 0x00007fff0000739c; ++ *((unsigned long *)&__m256i_op11) = 0x000040b200002fd4; ++ *((unsigned long *)&__m256i_op10) = 0x00007fff0000739c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000739c; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000ff; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff800000000000; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op02) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op01) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op00) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op13) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op12) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_op11) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op10) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_result3) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_result2) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_result1) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_result0) = 0x6040190d00000000; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op02) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op00) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x03fbfffc03fc07fc; ++ *((unsigned long *)&__m256i_op12) = 0x8000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x03fbfffc03fc07fc; ++ *((unsigned long *)&__m256i_op10) = 0x8000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000ffff0000ffff; ++ __m256i_out = __lasx_xvinsve0_d (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_op02) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_op00) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_result2) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff8001ffff0001; ++ __m256i_out = __lasx_xvinsve0_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvprem.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvprem.c +new file mode 100644 +index 000000000..9346f9bfb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvprem.c +@@ -0,0 +1,20 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpremi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpremi.c +new file mode 100644 +index 000000000..9346f9bfb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpremi.c +@@ -0,0 +1,20 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvextl-xvsra-xvsr.patch
Added
@@ -0,0 +1,4737 @@ +From bf5805833fc26d26a1fbbdc7dfe10109c0c676f9 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:49:41 +0800 +Subject: PATCH 107/124 LoongArch: Add tests for ASX vector + xvextl/xvsra/xvsran/xvsrarn instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvextl-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvextl-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsra.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrai.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsran.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrani.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrar.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrari.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrarn.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrarni.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvextl-1.c | 86 +++ + .../loongarch/vector/lasx/lasx-xvextl-2.c | 163 ++++ + .../loongarch/vector/lasx/lasx-xvsra.c | 545 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrai.c | 504 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvsran.c | 455 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsrani.c | 545 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrar.c | 725 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrari.c | 471 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrarn.c | 500 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrarni.c | 636 +++++++++++++++ + 10 files changed, 4630 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsra.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrai.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsran.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrani.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrar.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrari.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarni.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-1.c +new file mode 100644 +index 000000000..c0d3e8e75 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-1.c +@@ -0,0 +1,86 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x43ef878780000009; ++ __m256i_out = __lasx_xvextl_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000201220001011c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000201220001011c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000201220001011c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000201220001011c; ++ __m256i_out = __lasx_xvextl_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_q_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-2.c +new file mode 100644 +index 000000000..8c7ab4ed3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvextl-2.c +@@ -0,0 +1,163 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000083f95466; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0101010100005400; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000083f95466; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0101010100005400; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvextl_qu_du (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsra.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsra.c +new file mode 100644 +index 000000000..2bf9ae9c3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsra.c +@@ -0,0 +1,545 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xc5890a0a07070707; ++ *((unsigned long *)&__m256i_op12) = 0x006be0e4180b8024; ++ *((unsigned long *)&__m256i_op11) = 0x1b399540334c966c; ++ *((unsigned long *)&__m256i_op10) = 0x71d7dd7aefcac001; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffbf7f7fff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe651bfff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffbf7f7fff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffe651bfff; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op13) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffe0000000; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800000004; ++ *((unsigned long *)&__m256i_op02) = 0x0000bf6e0000c916; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000030000fff3; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000bf6e0000c916; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000030000fff3; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff0e400; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffe40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fff0e400; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x9cffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x9cffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1cfd000000000000; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000017e007ffe02; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_op11) = 0x017e00ff017e00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000004500f300fb; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000004500f300fb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op02) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op01) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op00) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_result3) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_result2) = 0x6161616100000018; ++ *((unsigned long *)&__m256i_result1) = 0x6161616161616161; ++ *((unsigned long *)&__m256i_result0) = 0x6161616100000018; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_op02) = 0x007f007f0081007f; ++ *((unsigned long *)&__m256i_op01) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_op00) = 0x007f007f0081007f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_result2) = 0x007f007f0081007f; ++ *((unsigned long *)&__m256i_result1) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_result0) = 0x007f007f0081007f; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_op02) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_op00) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_result2) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_result0) = 0x01fe01ae00ff00ff; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op02) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op01) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op00) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result2) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result1) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_result0) = 0x7fe1ffe0ffe1ffe0; ++ __m256i_out = __lasx_xvsra_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op02) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op01) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op00) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0007000700070007; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op02) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op01) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op00) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op13) = 0xff0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op12) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op11) = 0xff0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op10) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op02) = 0x6040190d20227a78; ++ *((unsigned long *)&__m256i_op01) = 0x132feeabd2d33b38; ++ *((unsigned long *)&__m256i_op00) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op12) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_op11) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op10) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000c0300000019a; ++ *((unsigned long *)&__m256i_result2) = 0x0c08032100004044; ++ *((unsigned long *)&__m256i_result1) = 0x0000265ffa5a6767; ++ *((unsigned long *)&__m256i_result0) = 0x0c08032100000000; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f433c78; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsra_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00feff0100feff01; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00feff0100feff01; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_op02) = 0xffff800300000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_op00) = 0xffff800300000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_result2) = 0xffff800300000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_result0) = 0xffff800300000000; ++ __m256i_out = __lasx_xvsra_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff000000017fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff000000017fff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsra_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000f00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000f00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsra_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrai.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrai.c +new file mode 100644 +index 000000000..a51be899b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrai.c +@@ -0,0 +1,504 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00d6c1c830160048; ++ *((unsigned long *)&__m256i_op01) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_op00) = 0xe3aebaf4df958004; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x006be0e4180b0024; ++ *((unsigned long *)&__m256i_result1) = 0x1b39153f334b166b; ++ *((unsigned long *)&__m256i_result0) = 0xf1d7dd7aefcac002; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x36); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op02) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op01) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op00) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result3) = 0x1555156a1555156a; ++ *((unsigned long *)&__m256i_result2) = 0x1555156a1555156a; ++ *((unsigned long *)&__m256i_result1) = 0x1555156a1555156a; ++ *((unsigned long *)&__m256i_result0) = 0x1555156a1555156a; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000bea20000e127; ++ *((unsigned long *)&__m256i_op02) = 0x0000c0460000721f; ++ *((unsigned long *)&__m256i_op01) = 0x0000de910000f010; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000006f9; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000bea20; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000c0460; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000de910; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffff800fffff800; ++ *((unsigned long *)&__m256i_result2) = 0xfffff800fffff800; ++ *((unsigned long *)&__m256i_result1) = 0xfffff800fffff800; ++ *((unsigned long *)&__m256i_result0) = 0xfffff800fffff800; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007f017f01; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007f017f01; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000007f017f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000007f017f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0fff01800fff0181; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0fff01800fff0181; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0007ff800007ff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0007ff800007ff80; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff000000000000; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000f91; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000f91; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op02) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op00) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff00ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff00ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000000000; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ffff0000; ++ *((unsigned long *)&__m256i_op02) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffc03fffffffc0; ++ *((unsigned long *)&__m256i_result2) = 0xffffc00000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffc03fffffffc0; ++ *((unsigned long *)&__m256i_result0) = 0xffffc00000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000007ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000007ffffffff; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000fef0ff0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000fef0ff0; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc008fa01c0090000; ++ *((unsigned long *)&__m256i_op02) = 0x3f804000c008f404; ++ *((unsigned long *)&__m256i_op01) = 0xc008fa01c0090000; ++ *((unsigned long *)&__m256i_op00) = 0x3f804000c008f404; ++ *((unsigned long *)&__m256i_result3) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_result2) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_result1) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_result0) = 0x001fc0200060047a; ++ __m256i_out = __lasx_xvsrai_d (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op02) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_op01) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op00) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_result3) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000fffe00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000fffe00000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op02) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op01) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op00) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_result3) = 0x1e9e1e9e1e9e1e9e; ++ *((unsigned long *)&__m256i_result2) = 0x1e9e1e9e1e9e1e9e; ++ *((unsigned long *)&__m256i_result1) = 0x1e9e1e9e1e9e1e9e; ++ *((unsigned long *)&__m256i_result0) = 0x1e9e1e9e1e9e1e9e; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrai_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_result3) = 0xffc0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffc0000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff0000; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0005fff9; ++ *((unsigned long *)&__m256i_op02) = 0x04f004f204f204f0; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0005fff9; ++ *((unsigned long *)&__m256i_op00) = 0x04f004f204f204f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000900000009; ++ __m256i_out = __lasx_xvsrai_w (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x761ed60b5d7f0000; ++ *((unsigned long *)&__m256i_op02) = 0xdc9938afafe904f1; ++ *((unsigned long *)&__m256i_op01) = 0x761ed60b5d7f0000; ++ *((unsigned long *)&__m256i_op00) = 0xdc9938afafe904f1; ++ *((unsigned long *)&__m256i_result3) = 0x03b0feb002eb0000; ++ *((unsigned long *)&__m256i_result2) = 0xfee401c5fd7f0027; ++ *((unsigned long *)&__m256i_result1) = 0x03b0feb002eb0000; ++ *((unsigned long *)&__m256i_result0) = 0xfee401c5fd7f0027; ++ __m256i_out = __lasx_xvsrai_h (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsran.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsran.c +new file mode 100644 +index 000000000..e08934b12 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsran.c +@@ -0,0 +1,455 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op11) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000013ffffffec; ++ *((unsigned long *)&__m256i_op12) = 0x00000013ffffebd8; ++ *((unsigned long *)&__m256i_op11) = 0x00000013ffffffec; ++ *((unsigned long *)&__m256i_op10) = 0x00000013ffffebd8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op02) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op01) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op00) = 0xfebdff3eff3dff52; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m256i_op02) = 0x000000007ffe7ffe; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe7ffe7ffe8000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000807e7ffe; ++ *((unsigned long *)&__m256i_op13) = 0x8091811081118110; ++ *((unsigned long *)&__m256i_op12) = 0x80a6802680208015; ++ *((unsigned long *)&__m256i_op11) = 0x8091811081110013; ++ *((unsigned long *)&__m256i_op10) = 0x80a6802680200018; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffefffe0000feff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffeff0000007e7f; ++ __m256i_out = __lasx_xvsran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000800000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op12) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_op11) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op10) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff000000000000; ++ __m256i_out = __lasx_xvsran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000007c8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000007c8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001fe01fe; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000ff0100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001fe01fe; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000ff0100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000c8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000c8; ++ __m256i_out = __lasx_xvsran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000000e; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000000e; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000440800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000440800; ++ __m256i_out = __lasx_xvsran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op02) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op01) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op00) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3d3d3d3d3d3d3d3d; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000405; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000405; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfc01fc0101fe01dd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfc01fc0101fe01dd; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000055; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000054; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvsran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrani.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrani.c +new file mode 100644 +index 000000000..44c20a954 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrani.c +@@ -0,0 +1,545 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000003ffffffff; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xe1e800002f03988d; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xe1e800002f03988d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff0f400001781cc4; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff0f400001781cc4; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc5c4c5c5c5c5c5c5; ++ *((unsigned long *)&__m256i_op02) = 0xc5c545c545c545c5; ++ *((unsigned long *)&__m256i_op01) = 0xc5c4c5c5c5c5c5c5; ++ *((unsigned long *)&__m256i_op00) = 0xc5c545c545c545c5; ++ *((unsigned long *)&__m256i_op13) = 0x000000ff000000f8; ++ *((unsigned long *)&__m256i_op12) = 0xbc8ff0ffffffcff8; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff000000f8; ++ *((unsigned long *)&__m256i_op10) = 0xbc8ff0ffffffcff8; ++ *((unsigned long *)&__m256i_result3) = 0xfcfcfcfcfc040404; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fbfffffc; ++ *((unsigned long *)&__m256i_result1) = 0xfcfcfcfcfc040404; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fbfffffc; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x14131211100f0e0d; ++ *((unsigned long *)&__m256i_op02) = 0x0c0b0a0908070605; ++ *((unsigned long *)&__m256i_op01) = 0x14131211100f0e0d; ++ *((unsigned long *)&__m256i_op00) = 0x0c0b0a0908070605; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0a09080706050403; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0a09080706050403; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffefd; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffefd; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000080; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x40); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000242; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000242; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0707feb608c9328b; ++ *((unsigned long *)&__m256i_op02) = 0xc237bd65fc892985; ++ *((unsigned long *)&__m256i_op01) = 0x0707feb608c9328b; ++ *((unsigned long *)&__m256i_op00) = 0xc237bd65fc892985; ++ *((unsigned long *)&__m256i_op13) = 0x00150015003a402f; ++ *((unsigned long *)&__m256i_op12) = 0x333568ce26dcd055; ++ *((unsigned long *)&__m256i_op11) = 0x00150015003a402f; ++ *((unsigned long *)&__m256i_op10) = 0x333568ce26dcd055; ++ *((unsigned long *)&__m256i_result3) = 0x0e0f1192846ff912; ++ *((unsigned long *)&__m256i_result2) = 0x002a0074666a4db9; ++ *((unsigned long *)&__m256i_result1) = 0x0e0f1192846ff912; ++ *((unsigned long *)&__m256i_result0) = 0x002a0074666a4db9; ++ __m256i_out = __lasx_xvsrani_h_w (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffdfffffffdff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffdfffffffdff; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x37); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8080808000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8080808000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x3f7f7f7eff800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x3f7f7f7eff800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007efeff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007efeff00; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xff3eff3eff3eff3e; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffff3e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffff3e; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x70); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0002000200020018; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0002000200020008; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00c0000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0040000000000000; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrani_h_w (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00001fff200007ef; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000f0f0003; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000f1003; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op12) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op10) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000fefefe000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000fefefe000000; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1010101010101010; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000781; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result3) = 0x0008080808080808; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0008080808080808; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000003c; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x45); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00f3009500db00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op11) = 0x00f3009500db00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000003cc0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000003cc0; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x6a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000400100013; ++ *((unsigned long *)&__m256i_op02) = 0x0000000400100014; ++ *((unsigned long *)&__m256i_op01) = 0x0000000400100013; ++ *((unsigned long *)&__m256i_op00) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_op13) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op12) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_op10) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000020200000202; ++ *((unsigned long *)&__m256i_result2) = 0x4100004141410000; ++ *((unsigned long *)&__m256i_result1) = 0x0000020200000000; ++ *((unsigned long *)&__m256i_result0) = 0x4100004141410000; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000003; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000956a00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000956a00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xb500000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x007fffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xb500000000000000; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x29); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000001010100; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000405; ++ *((unsigned long *)&__m256i_op11) = 0x8000000001010100; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000405; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffe00000ffe00000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffe00000ffe00000; ++ __m256i_out = __lasx_xvsrani_h_w (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_w_d (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_w_d (__m256i_op0, __m256i_op1, 0x34); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op02) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op13) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op12) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op10) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x66); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffc0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffc0; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffff80; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffff80; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_b_h (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_h_w (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffce; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffce; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x6b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000040e7; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000040e7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000200000000000; ++ __m256i_out = __lasx_xvsrani_d_q (__m256i_op0, __m256i_op1, 0x21); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x3ff9fffa3ff9fffa; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x3ff9fffa3ff9fffa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007ff3; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007ff3; ++ __m256i_out = __lasx_xvsrani_w_d (__m256i_op0, __m256i_op1, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrar.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrar.c +new file mode 100644 +index 000000000..fb47385c0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrar.c +@@ -0,0 +1,725 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x38a966b31be83ee9; ++ *((unsigned long *)&__m256i_op02) = 0x5f6108dc25b80001; ++ *((unsigned long *)&__m256i_op01) = 0xf41a56e8a20878d7; ++ *((unsigned long *)&__m256i_op00) = 0x683b8b67e20c0001; ++ *((unsigned long *)&__m256i_op13) = 0x000000000501e99b; ++ *((unsigned long *)&__m256i_op12) = 0x0000000109973de7; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001020f22; ++ *((unsigned long *)&__m256i_op10) = 0x00000001890b7a39; ++ *((unsigned long *)&__m256i_result3) = 0x38a966b301f41ffd; ++ *((unsigned long *)&__m256i_result2) = 0x5f6108ee13ff0000; ++ *((unsigned long *)&__m256i_result1) = 0xf41a56e8d10201f6; ++ *((unsigned long *)&__m256i_result0) = 0x683b8b34f1020001; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000707; ++ *((unsigned long *)&__m256i_op12) = 0x0000010200000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000070300000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x01480000052801a2; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffdcff64; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_op02) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_op01) = 0x0008000001010000; ++ *((unsigned long *)&__m256i_op00) = 0x0101000001010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_result2) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_result1) = 0x0008000001010000; ++ *((unsigned long *)&__m256i_result0) = 0x0101000001010000; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op12) = 0x0020000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op10) = 0x0020000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xff01ff3400000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff83ff01; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffcc8000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff82037dfd0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op02) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_op01) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op00) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_result2) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_result1) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_result0) = 0x45baa7ef6a95a985; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op12) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_op11) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op10) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000800; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d0000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000001dc; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000001dc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000001a00; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff02ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffff0100; ++ *((unsigned long *)&__m256i_op00) = 0xff00fefffeff02ff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff0100; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000100; ++ *((unsigned long *)&__m256i_result0) = 0xff00feff00000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x2b2a292827262524; ++ *((unsigned long *)&__m256i_op12) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_op11) = 0x2b2a292827262524; ++ *((unsigned long *)&__m256i_op10) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_op02) = 0x8e8e8e8e8f0e8e8e; ++ *((unsigned long *)&__m256i_op01) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_op00) = 0x8e8e8e8e8f0e8e8e; ++ *((unsigned long *)&__m256i_op13) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_result3) = 0x7171717171010101; ++ *((unsigned long *)&__m256i_result2) = 0x8e8e8e8e8f00ffff; ++ *((unsigned long *)&__m256i_result1) = 0x7171717171010101; ++ *((unsigned long *)&__m256i_result0) = 0x8e8e8e8e8f00ffff; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvsrar_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op02) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op01) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op00) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op13) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op12) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op11) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_op10) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_result3) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000001607f0000; ++ *((unsigned long *)&__m256i_result1) = 0x8000420080000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000001607f0000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_result2) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_result0) = 0x43ef878780000009; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_op12) = 0x00005053000000ff; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_op10) = 0x00005053000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff800000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_result3) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op02) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op01) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op00) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op12) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_op11) = 0x0000000800200027; ++ *((unsigned long *)&__m256i_op10) = 0x0000000800200028; ++ *((unsigned long *)&__m256i_result3) = 0x006018000000001a; ++ *((unsigned long *)&__m256i_result2) = 0x0060401900000000; ++ *((unsigned long *)&__m256i_result1) = 0x006018000000001a; ++ *((unsigned long *)&__m256i_result0) = 0x0060401900000000; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrar_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000040404040; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ffffff1dff; ++ *((unsigned long *)&__m256i_op02) = 0xffff1dffffff1dff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ffffff1dff; ++ *((unsigned long *)&__m256i_op00) = 0xffff1dffffff1dff; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff1dffffff1dff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff1dffffff1dff; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrar_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrari.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrari.c +new file mode 100644 +index 000000000..63ba92ead +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrari.c +@@ -0,0 +1,471 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x81f7f2599f0509c2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x51136d3c78388916; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffc0fcffffcf83; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000288a00003c1c; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_op02) = 0x00d6c1c830160048; ++ *((unsigned long *)&__m256i_op01) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_op00) = 0xe3aebaf4df958004; ++ *((unsigned long *)&__m256i_result3) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100020001; ++ *((unsigned long *)&__m256i_result0) = 0x0000fffffffffffe; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00001f41ffffbf00; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000040000fff8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00007dfd; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00007dfd; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x22); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x35); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x20fc000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x20fc000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007f0000007f0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x007f0000007f0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000003f8000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000003f8000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x10fbe1e2e0000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x10fbe1e2e0000002; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op02) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000040004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000040004; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff8000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0x26); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result2) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result1) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result0) = 0x0000400000004000; ++ __m256i_out = __lasx_xvsrari_w (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrari_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op02) = 0x7fff81007fff0100; ++ *((unsigned long *)&__m256i_op01) = 0x0000010000000100; ++ *((unsigned long *)&__m256i_op00) = 0x7fff81007fff0100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000008000000; ++ *((unsigned long *)&__m256i_result2) = 0x0003fffc0803fff8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000008000000; ++ *((unsigned long *)&__m256i_result0) = 0x0003fffc0803fff8; ++ __m256i_out = __lasx_xvsrari_d (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarn.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarn.c +new file mode 100644 +index 000000000..c145f7ff3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarn.c +@@ -0,0 +1,500 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6100000800060005; ++ *((unsigned long *)&__m256i_op02) = 0x5ee1c073b800c916; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5ff00007fff9fff3; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0209fefb08140000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00080000000cc916; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000006fff3; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6100000800060005; ++ *((unsigned long *)&__m256i_op02) = 0x5ee1c073b800c916; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5ff00007fff9fff3; ++ *((unsigned long *)&__m256i_op13) = 0x00ffff00ff000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00080005c073c916; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000100000007fff3; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00050008000e0010; ++ *((unsigned long *)&__m256i_op12) = 0x0007000800100010; ++ *((unsigned long *)&__m256i_op11) = 0x00050008000e0010; ++ *((unsigned long *)&__m256i_op10) = 0x0007000800100010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000002affaa; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff002affaa; ++ *((unsigned long *)&__m256i_op01) = 0x00000000002affaa; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffd50055; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x002affaa00000000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000001f0000001f; ++ *((unsigned long *)&__m256i_op10) = 0x0000001f0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00007f7f00007f00; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00007f7f00007fff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_op12) = 0x000000000007fff8; ++ *((unsigned long *)&__m256i_op11) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_op10) = 0x000000000007fff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007f00ff00000000; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000abff0000abff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000abff0000abff; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_op02) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_op00) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_op13) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op12) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_op11) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op10) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff800000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op02) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000070007000; ++ *((unsigned long *)&__m256i_op00) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op13) = 0x4040403fd03fd040; ++ *((unsigned long *)&__m256i_op12) = 0x4040403fd03fd040; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffd03fd040; ++ *((unsigned long *)&__m256i_op10) = 0x4040403fd03fd040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001010000010100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000010100; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_op12) = 0x8800c800c800c801; ++ *((unsigned long *)&__m256i_op11) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_op10) = 0x8800c800c800c801; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000c8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000c8; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000086000000; ++ *((unsigned long *)&__m256i_op02) = 0x00040ff288000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000086000000; ++ *((unsigned long *)&__m256i_op00) = 0x00040ff288000000; ++ *((unsigned long *)&__m256i_op13) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_op12) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_op11) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_op10) = 0x5555555555555555; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000fc300000fc40; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc008fa01c0090000; ++ *((unsigned long *)&__m256i_op02) = 0x3f804000c008f404; ++ *((unsigned long *)&__m256i_op01) = 0xc008fa01c0090000; ++ *((unsigned long *)&__m256i_op00) = 0x3f804000c008f404; ++ *((unsigned long *)&__m256i_op13) = 0x82ff902d83000000; ++ *((unsigned long *)&__m256i_op12) = 0x7f80000082fe0bd9; ++ *((unsigned long *)&__m256i_op11) = 0x82ff902d83000000; ++ *((unsigned long *)&__m256i_op10) = 0x7f80000082fe0bd9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xc0090000c0200060; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xc0090000c0200060; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xf3f3f3f3f3f3f4f3; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xf3f3f3f3f3f3f4f3; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000f3f3f4f3; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000f3f3f4f3; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fff8579f; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op02) = 0xfefefefe01010101; ++ *((unsigned long *)&__m256i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op00) = 0xfefefefe01010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefe01010101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefe01010101; ++ __m256i_out = __lasx_xvsrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op12) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op11) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op10) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000810001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000810001; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010110; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010110; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op02) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op01) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op00) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op13) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_op12) = 0x8768876887688769; ++ *((unsigned long *)&__m256i_op11) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_op10) = 0x8768876887688769; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000104000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000104000200; ++ __m256i_out = __lasx_xvsrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarni.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarni.c +new file mode 100644 +index 000000000..b5c0fca74 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrarni.c +@@ -0,0 +1,636 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000007f007f5; ++ *((unsigned long *)&__m256i_op13) = 0x002e4db200000000; ++ *((unsigned long *)&__m256i_op12) = 0x000315ac0000d658; ++ *((unsigned long *)&__m256i_op11) = 0x00735278007cf94c; ++ *((unsigned long *)&__m256i_op10) = 0x0003ed8800031b38; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffcfa; ++ *((unsigned long *)&__m256i_op11) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff8fffffff8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff8fc000000; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7ff77fff7ff7; ++ *((unsigned long *)&__m256i_op01) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7ff77fff7ff7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000022; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result1) = 0x0000002000000022; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000004; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x22); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000016600000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000016600000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x7f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000055; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000055; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x50); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_b_h (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x20); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00550f0000550f00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op12) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op11) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op10) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_result3) = 0x0000000015c015c0; ++ *((unsigned long *)&__m256i_result2) = 0xc0c0c0cdc0c0c0cd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xc0c0c0cdc0c0c0cd; ++ __m256i_out = __lasx_xvsrarni_b_h (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op02) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op01) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op00) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op13) = 0x0003030300000300; ++ *((unsigned long *)&__m256i_op12) = 0x0003030300000300; ++ *((unsigned long *)&__m256i_op11) = 0x0003030300000100; ++ *((unsigned long *)&__m256i_op10) = 0x0003030300000100; ++ *((unsigned long *)&__m256i_result3) = 0x00f800f800f800f8; ++ *((unsigned long *)&__m256i_result2) = 0x0018181800181818; ++ *((unsigned long *)&__m256i_result1) = 0x00f800f800f800f8; ++ *((unsigned long *)&__m256i_result0) = 0x0018181800181818; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x43d03bfff827ea21; ++ *((unsigned long *)&__m256i_op12) = 0x43dac1f2a3804ff0; ++ *((unsigned long *)&__m256i_op11) = 0x43d03bfff827e9f9; ++ *((unsigned long *)&__m256i_op10) = 0x43e019c657c7d050; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xe8001411edf9c0f8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xe80014fdf0e3e428; ++ __m256i_out = __lasx_xvsrarni_b_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0fff0ff01ff14; ++ *((unsigned long *)&__m256i_op02) = 0xfff0fff0fff10003; ++ *((unsigned long *)&__m256i_op01) = 0xfff0fff0ff01ff14; ++ *((unsigned long *)&__m256i_op00) = 0xfff0fff0fff10003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfefee0e3fefefe00; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfefee0e3fefefe00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000001fffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000001fffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000001fffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000001fffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op02) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x007f0000007f0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x007f0000007f0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f8f7f8f800f800; ++ *((unsigned long *)&__m256i_op02) = 0x00003f780000ff80; ++ *((unsigned long *)&__m256i_op01) = 0xf7f8f7f80000fff9; ++ *((unsigned long *)&__m256i_op00) = 0x00003f780000ff80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00001fff200007ef; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_op02) = 0x8e8e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_op01) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_op00) = 0x8e8e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x01c601c6fe3afe3a; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x01c601c6fe3afe3a; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op12) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op11) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op10) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003f3f00004040; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f010700c70106; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f010700c70106; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000010211921; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000010211921; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7ffffffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7ffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x82ff902d83000000; ++ *((unsigned long *)&__m256i_op12) = 0x7f80000082fe0bd9; ++ *((unsigned long *)&__m256i_op11) = 0x82ff902d83000000; ++ *((unsigned long *)&__m256i_op10) = 0x7f80000082fe0bd9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000001; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_w_d (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000080ff; ++ *((unsigned long *)&__m256i_op01) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000080ff; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0x08000000000000f8; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x08000000000000f8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_b_h (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op12) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1010101010101010; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff8; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_result2) = 0x2020000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_result0) = 0x2020000000000000; ++ __m256i_out = __lasx_xvsrarni_d_q (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x4); ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_b_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op02) = 0x03acfc5303260e81; ++ *((unsigned long *)&__m256i_op01) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op00) = 0x03acfc5303260e81; ++ *((unsigned long *)&__m256i_op13) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op12) = 0x03acfc5303260e81; ++ *((unsigned long *)&__m256i_op11) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op10) = 0x03acfc5303260e81; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrarni_h_w (__m256i_op0, __m256i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvfcmp-caf-ceq-cl.patch
Added
@@ -0,0 +1,4510 @@ +From ab8716fe8109c738ac02b641160350d2b351466b Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:45:33 +0800 +Subject: PATCH 116/124 LoongArch: Add tests for ASX vector + xvfcmp{caf/ceq/cle/clt/cne/cor/cun} instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_caf_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_ceq_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cle_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_clt_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cne_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cor_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cun_s.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvfcmp_caf_s.c | 446 ++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_ceq_s.c | 977 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_cle_s.c | 759 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_clt_s.c | 675 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_cne_s.c | 872 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_cor_s.c | 340 ++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_cun_s.c | 361 +++++++ + 7 files changed, 4430 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_caf_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_ceq_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cle_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_clt_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cne_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cor_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cun_s.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_caf_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_caf_s.c +new file mode 100644 +index 000000000..fa3372358 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_caf_s.c +@@ -0,0 +1,446 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xff56ff55; ++ *((int *)&__m256_op04) = 0xff01ff01; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xff56ff55; ++ *((int *)&__m256_op00) = 0xff01ff01; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x0000abff; ++ *((int *)&__m256_op14) = 0x0000abff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x0000abff; ++ *((int *)&__m256_op10) = 0x0000abff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000001; ++ *((int *)&__m256_op04) = 0x0000000a; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000001; ++ *((int *)&__m256_op00) = 0x0000000a; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000040; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x5d20a0a1; ++ *((int *)&__m256_op16) = 0x5d20a0a1; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x5d20a0a1; ++ *((int *)&__m256_op12) = 0x5d20a0a1; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0003ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffff8000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffff8000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffff8000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffff8000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xe07de080; ++ *((int *)&__m256_op04) = 0x1f20607a; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xe07de080; ++ *((int *)&__m256_op00) = 0x1f20607a; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xe07de080; ++ *((int *)&__m256_op14) = 0x1f20607a; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xe07de080; ++ *((int *)&__m256_op10) = 0x1f20607a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xe07de080; ++ *((int *)&__m256_op14) = 0x1f20607a; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xe07de080; ++ *((int *)&__m256_op10) = 0x1f20607a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000010; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000010; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xa5a5a5a5a5a5a5a5; ++ *((unsigned long *)&__m256d_op12) = 0xa5a5a5a5a5a99e03; ++ *((unsigned long *)&__m256d_op11) = 0xa5a5a5a5a5a5a5a5; ++ *((unsigned long *)&__m256d_op10) = 0xa5a5a5a5a5a99e03; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000045; ++ *((unsigned long *)&__m256d_op02) = 0x00000000000d0005; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000045; ++ *((unsigned long *)&__m256d_op00) = 0x00000000000d0005; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000045; ++ *((unsigned long *)&__m256d_op12) = 0x00000000000d0005; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000045; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x24342434ffff2435; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x24342434ffff2435; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00003fe000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00003fe000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000013; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000013; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000013; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000013; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256d_op02) = 0xfffe97a1df5b41b0; ++ *((unsigned long *)&__m256d_op01) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256d_op00) = 0xfffe97a1df5b41b0; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_caf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_ceq_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_ceq_s.c +new file mode 100644 +index 000000000..6d6649f6f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_ceq_s.c +@@ -0,0 +1,977 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00010101; ++ *((int *)&__m256_op06) = 0x01010101; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00010100; ++ *((int *)&__m256_op01) = 0x00010000; ++ *((int *)&__m256_op00) = 0x01000100; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xbf7f7fff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xe651bfff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x000000ff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x000000ff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x0000ffff; ++ *((int *)&__m256_op16) = 0xc0008001; ++ *((int *)&__m256_op15) = 0x0000ffff; ++ *((int *)&__m256_op14) = 0xc0008001; ++ *((int *)&__m256_op13) = 0x0000ffff; ++ *((int *)&__m256_op12) = 0xc0008001; ++ *((int *)&__m256_op11) = 0x0000ffff; ++ *((int *)&__m256_op10) = 0xc0008001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffc6ffc6; ++ *((int *)&__m256_op06) = 0x003a003a; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffc6ffc6; ++ *((int *)&__m256_op02) = 0x003a003a; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x71717171; ++ *((int *)&__m256_op16) = 0x71010101; ++ *((int *)&__m256_op15) = 0x8e8e8e8e; ++ *((int *)&__m256_op14) = 0x8f00ffff; ++ *((int *)&__m256_op13) = 0x71717171; ++ *((int *)&__m256_op12) = 0x71010101; ++ *((int *)&__m256_op11) = 0x8e8e8e8e; ++ *((int *)&__m256_op10) = 0x8f00ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x000e000e; ++ *((int *)&__m256_op14) = 0x000e000e; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x000e000e; ++ *((int *)&__m256_op10) = 0x000e000e; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000043; ++ *((int *)&__m256_op04) = 0x0207f944; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000043; ++ *((int *)&__m256_op00) = 0x0207f944; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000001; ++ *((int *)&__m256_op16) = 0x9ffdf403; ++ *((int *)&__m256_op15) = 0x00000001; ++ *((int *)&__m256_op14) = 0x1ffd97c3; ++ *((int *)&__m256_op13) = 0x00000001; ++ *((int *)&__m256_op12) = 0x9ffdf403; ++ *((int *)&__m256_op11) = 0x00000001; ++ *((int *)&__m256_op10) = 0x1ffd97c3; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x7fff7fff; ++ *((int *)&__m256_op04) = 0x7fff7fff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x7fff7fff; ++ *((int *)&__m256_op00) = 0x7fff7fff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000808; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xbea2e127; ++ *((int *)&__m256_op16) = 0xc046721f; ++ *((int *)&__m256_op15) = 0x1729c073; ++ *((int *)&__m256_op14) = 0x816edebe; ++ *((int *)&__m256_op13) = 0xde91f010; ++ *((int *)&__m256_op12) = 0x000006f9; ++ *((int *)&__m256_op11) = 0x5ef1f90e; ++ *((int *)&__m256_op10) = 0xfefaf30d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000200; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000200; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000200; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000200; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000009; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000009; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000009; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffb80000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffb80000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000ffff; ++ *((int *)&__m256_op06) = 0x0000ffff; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x0000ffff; ++ *((int *)&__m256_op02) = 0x0000ffff; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfff0fff0; ++ *((int *)&__m256_op06) = 0xff01ff01; ++ *((int *)&__m256_op05) = 0xfff0fff0; ++ *((int *)&__m256_op04) = 0xfff0fff0; ++ *((int *)&__m256_op03) = 0xfff0fff0; ++ *((int *)&__m256_op02) = 0xff01ff01; ++ *((int *)&__m256_op01) = 0xfff0fff0; ++ *((int *)&__m256_op00) = 0xfff0fff0; ++ *((int *)&__m256_op17) = 0xffefffef; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xffefffef; ++ *((int *)&__m256_op14) = 0xffefffef; ++ *((int *)&__m256_op13) = 0xffefffef; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xffefffef; ++ *((int *)&__m256_op10) = 0xffefffef; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x0000ffb1; ++ *((int *)&__m256_op16) = 0x0001ff8f; ++ *((int *)&__m256_op15) = 0x0001004c; ++ *((int *)&__m256_op14) = 0x0001ff87; ++ *((int *)&__m256_op13) = 0x0000ffb1; ++ *((int *)&__m256_op12) = 0x0001ff8f; ++ *((int *)&__m256_op11) = 0x0001004c; ++ *((int *)&__m256_op10) = 0x0001ff87; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00010001; ++ *((int *)&__m256_op16) = 0x00010001; ++ *((int *)&__m256_op15) = 0x00010001; ++ *((int *)&__m256_op14) = 0x00010001; ++ *((int *)&__m256_op13) = 0x00010001; ++ *((int *)&__m256_op12) = 0x00010001; ++ *((int *)&__m256_op11) = 0x00010001; ++ *((int *)&__m256_op10) = 0x00010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffff0000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffff0000; ++ *((int *)&__m256_op04) = 0xffff0000; ++ *((int *)&__m256_op03) = 0xffff0000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffff0000; ++ *((int *)&__m256_op00) = 0xffff0000; ++ *((int *)&__m256_op17) = 0x007f8080; ++ *((int *)&__m256_op16) = 0x007f007f; ++ *((int *)&__m256_op15) = 0x007f8080; ++ *((int *)&__m256_op14) = 0x007f007f; ++ *((int *)&__m256_op13) = 0x007f8080; ++ *((int *)&__m256_op12) = 0x007f007f; ++ *((int *)&__m256_op11) = 0x007f8080; ++ *((int *)&__m256_op10) = 0x007f007f; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000033; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000033; ++ *((int *)&__m256_op17) = 0x00004200; ++ *((int *)&__m256_op16) = 0x80000000; ++ *((int *)&__m256_op15) = 0x5fff5fff; ++ *((int *)&__m256_op14) = 0x607f0000; ++ *((int *)&__m256_op13) = 0x00004200; ++ *((int *)&__m256_op12) = 0x80000000; ++ *((int *)&__m256_op11) = 0x5fff5fff; ++ *((int *)&__m256_op10) = 0x607f0000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x7fff8000; ++ *((int *)&__m256_op16) = 0x7fff0000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00008000; ++ *((int *)&__m256_op13) = 0x7fff8000; ++ *((int *)&__m256_op12) = 0x7fff0000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00008000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0x00100010; ++ *((int *)&__m256_op16) = 0x00030000; ++ *((int *)&__m256_op15) = 0x00100010; ++ *((int *)&__m256_op14) = 0x00030000; ++ *((int *)&__m256_op13) = 0x00100010; ++ *((int *)&__m256_op12) = 0x00030000; ++ *((int *)&__m256_op11) = 0x00100010; ++ *((int *)&__m256_op10) = 0x00030000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xf90c0c0c00000000; ++ *((unsigned long *)&__m256d_op02) = 0x0ca40c0c0c0c0cc0; ++ *((unsigned long *)&__m256d_op01) = 0x0c0c0c0c0cb60cc0; ++ *((unsigned long *)&__m256d_op00) = 0xfbe0b80c960c96d0; ++ *((unsigned long *)&__m256d_op13) = 0x1b9763952fc4c101; ++ *((unsigned long *)&__m256d_op12) = 0xe37affb42fc05f69; ++ *((unsigned long *)&__m256d_op11) = 0x18b988e64facb558; ++ *((unsigned long *)&__m256d_op10) = 0xe5fb66c81da8e5bb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x001e001ea1bfa1bf; ++ *((unsigned long *)&__m256d_op02) = 0x001e001e83e5422e; ++ *((unsigned long *)&__m256d_op01) = 0x001e001ea1bfa1bf; ++ *((unsigned long *)&__m256d_op00) = 0x011f011f0244420e; ++ *((unsigned long *)&__m256d_op13) = 0xfffe00f7ffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xfffffffffff629d7; ++ *((unsigned long *)&__m256d_op11) = 0xfffe00f7ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xfffffffffff629d7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000200; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000200; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000000007ffff; ++ *((unsigned long *)&__m256d_op02) = 0x000000000007ffff; ++ *((unsigned long *)&__m256d_op01) = 0x000000000007ffff; ++ *((unsigned long *)&__m256d_op00) = 0x000000000007ffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256d_op12) = 0x7ffffffffffffffe; ++ *((unsigned long *)&__m256d_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256d_op10) = 0x7ffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256d_op12) = 0x6040190d00000000; ++ *((unsigned long *)&__m256d_op11) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256d_op10) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256d_op02) = 0x408480007fff0000; ++ *((unsigned long *)&__m256d_op01) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256d_op00) = 0x408480007fff0000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256d_op01) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256d_op13) = 0xffe6ffe6e6800001; ++ *((unsigned long *)&__m256d_op12) = 0x19660019ff806680; ++ *((unsigned long *)&__m256d_op11) = 0xffe6ffe6e6800001; ++ *((unsigned long *)&__m256d_op10) = 0x19660019ff806680; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000010100000101; ++ *((unsigned long *)&__m256d_op12) = 0x0000010100000101; ++ *((unsigned long *)&__m256d_op11) = 0x0000010100000101; ++ *((unsigned long *)&__m256d_op10) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_ceq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000001000000010; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000001000000010; ++ *((unsigned long *)&__m256d_op13) = 0x45d5555545d55555; ++ *((unsigned long *)&__m256d_op12) = 0x74555555e8aaaaaa; ++ *((unsigned long *)&__m256d_op11) = 0x45d5555545d55555; ++ *((unsigned long *)&__m256d_op10) = 0x74555555e8aaaaaa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256d_op12) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256d_op11) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256d_op10) = 0xfffffffffffffff6; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0003030300000300; ++ *((unsigned long *)&__m256d_op02) = 0x0003030300000300; ++ *((unsigned long *)&__m256d_op01) = 0x0003030300000100; ++ *((unsigned long *)&__m256d_op00) = 0x0003030300000100; ++ *((unsigned long *)&__m256d_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256d_op13) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256d_op12) = 0x408480007fff0000; ++ *((unsigned long *)&__m256d_op11) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256d_op10) = 0x408480007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff0007a861; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff0007a861; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000007f00000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000007f00000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000007f00000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000007f00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256d_op02) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256d_op01) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256d_op00) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cle_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cle_s.c +new file mode 100644 +index 000000000..a64dd7598 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cle_s.c +@@ -0,0 +1,759 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0018796d; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00fffb04; ++ *((int *)&__m256_op06) = 0x02fddf20; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00fffb04; ++ *((int *)&__m256_op02) = 0x02fddf20; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x41dfffc0; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x41dfffdf; ++ *((int *)&__m256_op12) = 0xffc00000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffee; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffee; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffee; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffee; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x01fe007a; ++ *((int *)&__m256_op06) = 0x01c40110; ++ *((int *)&__m256_op05) = 0x019d00a2; ++ *((int *)&__m256_op04) = 0x0039fff9; ++ *((int *)&__m256_op03) = 0x01fe007a; ++ *((int *)&__m256_op02) = 0x01c40110; ++ *((int *)&__m256_op01) = 0x019d00a2; ++ *((int *)&__m256_op00) = 0x003a0000; ++ *((int *)&__m256_op17) = 0x0000fffe; ++ *((int *)&__m256_op16) = 0x00800022; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x0000fffe; ++ *((int *)&__m256_op12) = 0x00800022; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x7fff7ffe; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x7fff7ffe; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000002; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000002; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000002; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000002; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x04000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x04000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x04000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x04000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000040; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000040; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00010001; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00010001; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00010001; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xe161616161614e60; ++ *((unsigned long *)&__m256d_op02) = 0xe161616161614e60; ++ *((unsigned long *)&__m256d_op01) = 0xe161616161614e60; ++ *((unsigned long *)&__m256d_op00) = 0xe161616161614e60; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000007773; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000003373; ++ *((unsigned long *)&__m256d_op13) = 0x1616161616161616; ++ *((unsigned long *)&__m256d_op12) = 0x161616167fffffff; ++ *((unsigned long *)&__m256d_op11) = 0x7ffe16167f161616; ++ *((unsigned long *)&__m256d_op10) = 0x161616167fffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffcc8000000000; ++ *((unsigned long *)&__m256d_op00) = 0x000000007dfdff4b; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xbabababababababa; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256d_op13) = 0x0101010183f9999b; ++ *((unsigned long *)&__m256d_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op11) = 0x01010101d58f43c9; ++ *((unsigned long *)&__m256d_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256d_op02) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256d_op00) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256d_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0100000001000100; ++ *((unsigned long *)&__m256d_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0100000001000100; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000002070145; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000002070145; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff0007a861; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff0007a861; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000003; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000003; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000003; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x1b976395; ++ *((int *)&__m256_op06) = 0x2fc4c101; ++ *((int *)&__m256_op05) = 0xe37affb4; ++ *((int *)&__m256_op04) = 0x2fc05f69; ++ *((int *)&__m256_op03) = 0x18b988e6; ++ *((int *)&__m256_op02) = 0x4facb558; ++ *((int *)&__m256_op01) = 0xe5fb66c8; ++ *((int *)&__m256_op00) = 0x1da8e5bb; ++ *((int *)&__m256_op17) = 0x01a72334; ++ *((int *)&__m256_op16) = 0xffff00ff; ++ *((int *)&__m256_op15) = 0xff4f6838; ++ *((int *)&__m256_op14) = 0xff937648; ++ *((int *)&__m256_op13) = 0x00a2afb7; ++ *((int *)&__m256_op12) = 0xfff00ecb; ++ *((int *)&__m256_op11) = 0xffce110f; ++ *((int *)&__m256_op10) = 0x004658c7; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x00001000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x00001000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000ff00; ++ *((int *)&__m256_op06) = 0x0000ffff; ++ *((int *)&__m256_op05) = 0x000000ff; ++ *((int *)&__m256_op04) = 0x000000ff; ++ *((int *)&__m256_op03) = 0x0000ff00; ++ *((int *)&__m256_op02) = 0x0000ffff; ++ *((int *)&__m256_op01) = 0x000000ff; ++ *((int *)&__m256_op00) = 0x000000ff; ++ *((int *)&__m256_op17) = 0x0000ffee; ++ *((int *)&__m256_op16) = 0x0000ff4c; ++ *((int *)&__m256_op15) = 0x0000ff05; ++ *((int *)&__m256_op14) = 0x0000ff3c; ++ *((int *)&__m256_op13) = 0x0000fff9; ++ *((int *)&__m256_op12) = 0x0000ff78; ++ *((int *)&__m256_op11) = 0x0000ffa8; ++ *((int *)&__m256_op10) = 0x0000ff31; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffff0000; ++ *((int *)&__m256_op14) = 0xffff0000; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffff0000; ++ *((int *)&__m256_op10) = 0xffff0000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000ff01; ++ *((int *)&__m256_op06) = 0x00ff0000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000ff01; ++ *((int *)&__m256_op03) = 0x0000ff01; ++ *((int *)&__m256_op02) = 0x00ff0000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000ff01; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00010000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00010000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x02000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x02000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x01010000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x01010000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffff0101; ++ *((int *)&__m256_op14) = 0x00000001; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffff0101; ++ *((int *)&__m256_op10) = 0x00000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffffffb; ++ *((int *)&__m256_op06) = 0xfffffffb; ++ *((int *)&__m256_op05) = 0xfffffffb; ++ *((int *)&__m256_op04) = 0xfffffffb; ++ *((int *)&__m256_op03) = 0xfffffffb; ++ *((int *)&__m256_op02) = 0xfffffffb; ++ *((int *)&__m256_op01) = 0xfffffffb; ++ *((int *)&__m256_op00) = 0xfffffffb; ++ *((int *)&__m256_op17) = 0x0000ffff; ++ *((int *)&__m256_op16) = 0x0001000e; ++ *((int *)&__m256_op15) = 0x0000ffff; ++ *((int *)&__m256_op14) = 0x0000ffff; ++ *((int *)&__m256_op13) = 0x0000ffff; ++ *((int *)&__m256_op12) = 0x0000ffff; ++ *((int *)&__m256_op11) = 0x0000ffff; ++ *((int *)&__m256_op10) = 0x0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x8080808280808082; ++ *((unsigned long *)&__m256d_op02) = 0x8080808280808082; ++ *((unsigned long *)&__m256d_op01) = 0x8080808280808080; ++ *((unsigned long *)&__m256d_op00) = 0x8080808280808082; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xfffeffff10000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xfffeffff10000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0f00204000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0f00204000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_clt_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_clt_s.c +new file mode 100644 +index 000000000..733cc00ee +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_clt_s.c +@@ -0,0 +1,675 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xfe02fe02; ++ *((int *)&__m256_op02) = 0xfee5fe22; ++ *((int *)&__m256_op01) = 0xff49fe42; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x0000ffff; ++ *((int *)&__m256_op16) = 0x0000ff80; ++ *((int *)&__m256_op15) = 0x00004686; ++ *((int *)&__m256_op14) = 0x00007f79; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0x0000ffff; ++ *((int *)&__m256_op11) = 0x0000f328; ++ *((int *)&__m256_op10) = 0x0000dfff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x01000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x01000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffff80cb; ++ *((int *)&__m256_op16) = 0xfffffdf8; ++ *((int *)&__m256_op15) = 0x00000815; ++ *((int *)&__m256_op14) = 0x00000104; ++ *((int *)&__m256_op13) = 0xffffffa4; ++ *((int *)&__m256_op12) = 0xfffffffd; ++ *((int *)&__m256_op11) = 0x00000007; ++ *((int *)&__m256_op10) = 0x00000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffff0000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00003f3f; ++ *((int *)&__m256_op14) = 0xc6c68787; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00003f3f; ++ *((int *)&__m256_op10) = 0x87870000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000002; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0x0101ffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0x0101ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x01000100; ++ *((int *)&__m256_op06) = 0x01000100; ++ *((int *)&__m256_op05) = 0x01000100; ++ *((int *)&__m256_op04) = 0x01000100; ++ *((int *)&__m256_op03) = 0x01000100; ++ *((int *)&__m256_op02) = 0x01000100; ++ *((int *)&__m256_op01) = 0x01000100; ++ *((int *)&__m256_op00) = 0x01000100; ++ *((int *)&__m256_op17) = 0x7f800000; ++ *((int *)&__m256_op16) = 0x7f800000; ++ *((int *)&__m256_op15) = 0x62d2acee; ++ *((int *)&__m256_op14) = 0x7fc00000; ++ *((int *)&__m256_op13) = 0x7f800000; ++ *((int *)&__m256_op12) = 0x7f800000; ++ *((int *)&__m256_op11) = 0x62d2acee; ++ *((int *)&__m256_op10) = 0x7fc00000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000ff01; ++ *((int *)&__m256_op06) = 0x00ff0000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000ff01; ++ *((int *)&__m256_op03) = 0x0000ff01; ++ *((int *)&__m256_op02) = 0x00ff0000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000ff01; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000808; ++ *((int *)&__m256_op14) = 0x00000808; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000808; ++ *((int *)&__m256_op10) = 0x00000808; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffff8000; ++ *((int *)&__m256_op05) = 0x7efefefe; ++ *((int *)&__m256_op04) = 0x80ffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x7efefefe; ++ *((int *)&__m256_op00) = 0x80ffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_clt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x0001ffaa; ++ *((int *)&__m256_op16) = 0x0000040e; ++ *((int *)&__m256_op15) = 0x00007168; ++ *((int *)&__m256_op14) = 0x00007bb6; ++ *((int *)&__m256_op13) = 0x0001ffe8; ++ *((int *)&__m256_op12) = 0x0001fe9c; ++ *((int *)&__m256_op11) = 0x00002282; ++ *((int *)&__m256_op10) = 0x00001680; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x01010101; ++ *((int *)&__m256_op05) = 0x55555501; ++ *((int *)&__m256_op04) = 0xfefefeab; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x01010101; ++ *((int *)&__m256_op01) = 0x55555501; ++ *((int *)&__m256_op00) = 0xfefefeab; ++ *((int *)&__m256_op17) = 0x00000105; ++ *((int *)&__m256_op16) = 0xfffffefb; ++ *((int *)&__m256_op15) = 0xffffff02; ++ *((int *)&__m256_op14) = 0x000000fe; ++ *((int *)&__m256_op13) = 0x00000105; ++ *((int *)&__m256_op12) = 0xfffffefb; ++ *((int *)&__m256_op11) = 0xffffff02; ++ *((int *)&__m256_op10) = 0x000000fe; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000080; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000080; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x0000ffce; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000fc7c; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x0000ffce; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000fc7c; ++ *((int *)&__m256_op17) = 0xe7e7e7e7; ++ *((int *)&__m256_op16) = 0xe7e7e7e7; ++ *((int *)&__m256_op15) = 0xe7e7e7e7; ++ *((int *)&__m256_op14) = 0xe7e7e7e7; ++ *((int *)&__m256_op13) = 0xe7e7e7e7; ++ *((int *)&__m256_op12) = 0xe7e7e7e7; ++ *((int *)&__m256_op11) = 0xe7e7e7e7; ++ *((int *)&__m256_op10) = 0xe7e7e7e7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0x0007a861; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0x0007a861; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00100010; ++ *((int *)&__m256_op15) = 0x00100010; ++ *((int *)&__m256_op14) = 0x00100010; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00100010; ++ *((int *)&__m256_op11) = 0x00100010; ++ *((int *)&__m256_op10) = 0x00100010; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x01010101; ++ *((int *)&__m256_op06) = 0x01010101; ++ *((int *)&__m256_op05) = 0x01010101; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x01010101; ++ *((int *)&__m256_op02) = 0x01010101; ++ *((int *)&__m256_op01) = 0x01010101; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_op17) = 0x000001e0; ++ *((int *)&__m256_op16) = 0x01e001e0; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x000001e0; ++ *((int *)&__m256_op12) = 0x01e001e0; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x000000000000007f; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256d_op13) = 0xf800d0d8ffffeecf; ++ *((unsigned long *)&__m256d_op12) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256d_op11) = 0xf800d0d8ffffeecf; ++ *((unsigned long *)&__m256d_op10) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x001ffffe00200000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x001ffffe00200000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_clt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x2020000020200000; ++ *((unsigned long *)&__m256d_op02) = 0x2020000020200000; ++ *((unsigned long *)&__m256d_op01) = 0x0008000001010000; ++ *((unsigned long *)&__m256d_op00) = 0x0101000001010000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op12) = 0x0002000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op10) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xfff1000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xfff1000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256d_op12) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256d_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256d_op10) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cne_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cne_s.c +new file mode 100644 +index 000000000..190741070 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cne_s.c +@@ -0,0 +1,872 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x7fff7fff; ++ *((int *)&__m256_op04) = 0x7fff7fff; ++ *((int *)&__m256_op03) = 0x7fff01fd; ++ *((int *)&__m256_op02) = 0x7fff7fff; ++ *((int *)&__m256_op01) = 0x00007fff; ++ *((int *)&__m256_op00) = 0x7fff7fff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000001; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000001; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xdededede; ++ *((int *)&__m256_op06) = 0xdededede; ++ *((int *)&__m256_op05) = 0xdededede; ++ *((int *)&__m256_op04) = 0xdededede; ++ *((int *)&__m256_op03) = 0xdededede; ++ *((int *)&__m256_op02) = 0xdededede; ++ *((int *)&__m256_op01) = 0xdededede; ++ *((int *)&__m256_op00) = 0xdededede; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000051; ++ *((int *)&__m256_op15) = 0x00001010; ++ *((int *)&__m256_op14) = 0x00000fff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000051; ++ *((int *)&__m256_op11) = 0x00001010; ++ *((int *)&__m256_op10) = 0x00000fff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000051; ++ *((int *)&__m256_op05) = 0x00001010; ++ *((int *)&__m256_op04) = 0x00000fff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000051; ++ *((int *)&__m256_op01) = 0x00001010; ++ *((int *)&__m256_op00) = 0x00000fff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000ffff; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x0000ffff; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x000007c8; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x000007c8; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x80000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x80000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000001f; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000001f; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x0000001f; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x0000001f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xfff8ff40; ++ *((int *)&__m256_op05) = 0x0000ff01; ++ *((int *)&__m256_op04) = 0x00090040; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xfff8ff40; ++ *((int *)&__m256_op01) = 0x0000ff01; ++ *((int *)&__m256_op00) = 0x00090040; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xff1cff1c; ++ *((int *)&__m256_op16) = 0xff1cff1c; ++ *((int *)&__m256_op15) = 0xff1cff1c; ++ *((int *)&__m256_op14) = 0xff1cff1c; ++ *((int *)&__m256_op13) = 0xff1cff1c; ++ *((int *)&__m256_op12) = 0xff1cff1c; ++ *((int *)&__m256_op11) = 0xff1cff1c; ++ *((int *)&__m256_op10) = 0xff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00fe01f0; ++ *((int *)&__m256_op06) = 0x00010000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00c40086; ++ *((int *)&__m256_op03) = 0x00fe01f0; ++ *((int *)&__m256_op02) = 0x00010000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00c40086; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x0000ffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x0000ffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000001; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x0fff0180; ++ *((int *)&__m256_op04) = 0x0fff0181; ++ *((int *)&__m256_op03) = 0x00000001; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x0fff0180; ++ *((int *)&__m256_op00) = 0x0fff0181; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0003ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xfffffe20; ++ *((int *)&__m256_op05) = 0x0000001d; ++ *((int *)&__m256_op04) = 0xfffffe1f; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x5fa00000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x5fa00000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000004; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00007f95; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000004; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00007f95; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x7f010000; ++ *((int *)&__m256_op05) = 0x00010000; ++ *((int *)&__m256_op04) = 0x00007f7f; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x7f010000; ++ *((int *)&__m256_op01) = 0x00010000; ++ *((int *)&__m256_op00) = 0x00007f7f; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x003f0200; ++ *((int *)&__m256_op06) = 0x01400200; ++ *((int *)&__m256_op05) = 0x003f00ff; ++ *((int *)&__m256_op04) = 0x003f00c4; ++ *((int *)&__m256_op03) = 0x003f0200; ++ *((int *)&__m256_op02) = 0x01400200; ++ *((int *)&__m256_op01) = 0x003f00ff; ++ *((int *)&__m256_op00) = 0x003f00c4; ++ *((int *)&__m256_op17) = 0x00000101; ++ *((int *)&__m256_op16) = 0x01010101; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000101; ++ *((int *)&__m256_op12) = 0x01010101; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x01fe000000ff00ff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x01fe000001fe0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0101010101010102; ++ *((unsigned long *)&__m256d_op02) = 0x0101010201010204; ++ *((unsigned long *)&__m256d_op01) = 0x0101010101010102; ++ *((unsigned long *)&__m256d_op00) = 0x0101010101010102; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000e00ff00ff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256d_op13) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256d_op12) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256d_op11) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256d_op10) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0101010127272525; ++ *((unsigned long *)&__m256d_op12) = 0x23a2a121179e951d; ++ *((unsigned long *)&__m256d_op11) = 0x0101010127272525; ++ *((unsigned long *)&__m256d_op10) = 0x23a2a121179e951d; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256d_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256d_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256d_op00) = 0x00000000000000e7; ++ *((unsigned long *)&__m256d_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256d_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000002000000020; ++ *((unsigned long *)&__m256d_op02) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256d_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m256d_op00) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256d_op13) = 0xdff8000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xdff8000000000000; ++ *((unsigned long *)&__m256d_op11) = 0xdff8000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xdff8000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000040002; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x000000000000007f; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xc600000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xc600000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op02) = 0x0002000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op00) = 0x0002000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op12) = 0x0002000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op10) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256d_op02) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256d_op01) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256d_op00) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256d_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256d_op12) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256d_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256d_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xff56ff55ff01ff01; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xff56ff55ff01ff01; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000800000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000800000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256d_op13) = 0x0004000400040004; ++ *((unsigned long *)&__m256d_op12) = 0x0004000500040005; ++ *((unsigned long *)&__m256d_op11) = 0x0004000400040004; ++ *((unsigned long *)&__m256d_op10) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cor_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cor_s.c +new file mode 100644 +index 000000000..8dd58f228 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cor_s.c +@@ -0,0 +1,340 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x01fe007a; ++ *((int *)&__m256_op16) = 0x01c40110; ++ *((int *)&__m256_op15) = 0x019d00a2; ++ *((int *)&__m256_op14) = 0x0039fff9; ++ *((int *)&__m256_op13) = 0x01fe007a; ++ *((int *)&__m256_op12) = 0x01c40110; ++ *((int *)&__m256_op11) = 0x019d00a2; ++ *((int *)&__m256_op10) = 0x003a0000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xfff10000; ++ *((int *)&__m256_op04) = 0xfff10000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xfff10000; ++ *((int *)&__m256_op00) = 0xfff10000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xfff10000; ++ *((int *)&__m256_op14) = 0xfff10000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffff00ffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x000000ff00000000; ++ *((unsigned long *)&__m256d_op13) = 0xffff00ffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x000000000000ff00; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffff295329; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffff295329; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256d_op02) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256d_op01) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256d_op00) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256d_op13) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256d_op12) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256d_op11) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256d_op10) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000020006; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000020006; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000020006; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x7); ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffff0100000001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffff0100000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x2); ++ *((unsigned long *)&__m256d_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256d_op12) = 0x000000000000ff01; ++ *((unsigned long *)&__m256d_op11) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256d_op10) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000050007; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000039; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cun_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cun_s.c +new file mode 100644 +index 000000000..3230c101d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_cun_s.c +@@ -0,0 +1,361 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x01ffffff; ++ *((int *)&__m256_op14) = 0xfe000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x01ffffff; ++ *((int *)&__m256_op10) = 0xfe000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000504f; ++ *((int *)&__m256_op06) = 0xffff3271; ++ *((int *)&__m256_op05) = 0xffff47b4; ++ *((int *)&__m256_op04) = 0xffff5879; ++ *((int *)&__m256_op03) = 0x0000504f; ++ *((int *)&__m256_op02) = 0xffff3271; ++ *((int *)&__m256_op01) = 0xffff47b4; ++ *((int *)&__m256_op00) = 0xffff5879; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xde00fe00; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x0000fe01; ++ *((int *)&__m256_op04) = 0x0000fe01; ++ *((int *)&__m256_op03) = 0xde00fe00; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x0000fe01; ++ *((int *)&__m256_op00) = 0x0000fe01; ++ *((int *)&__m256_op17) = 0x0000ffff; ++ *((int *)&__m256_op16) = 0x0000ffff; ++ *((int *)&__m256_op15) = 0x00ff00fe; ++ *((int *)&__m256_op14) = 0x00ff00fe; ++ *((int *)&__m256_op13) = 0x0000ffff; ++ *((int *)&__m256_op12) = 0x0000ffff; ++ *((int *)&__m256_op11) = 0x00ff00fe; ++ *((int *)&__m256_op10) = 0x00ff00fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xf3f3f3f3; ++ *((int *)&__m256_op06) = 0xf3f3f3f3; ++ *((int *)&__m256_op05) = 0xf3f3f3f3; ++ *((int *)&__m256_op04) = 0xf3f3f3f3; ++ *((int *)&__m256_op03) = 0xf3f3f3f3; ++ *((int *)&__m256_op02) = 0xf3f3f3f3; ++ *((int *)&__m256_op01) = 0xf3f3f3f3; ++ *((int *)&__m256_op00) = 0xf3f3f3f3; ++ *((int *)&__m256_op17) = 0xf3f3f3f3; ++ *((int *)&__m256_op16) = 0xf3f3f3f3; ++ *((int *)&__m256_op15) = 0xf3f3f3f3; ++ *((int *)&__m256_op14) = 0xf3f3f3f3; ++ *((int *)&__m256_op13) = 0xf3f3f3f3; ++ *((int *)&__m256_op12) = 0xf3f3f3f3; ++ *((int *)&__m256_op11) = 0xf3f3f3f3; ++ *((int *)&__m256_op10) = 0xf3f3f3f3; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0x0007a861; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0x0007a861; ++ *((int *)&__m256_op17) = 0x80008000; ++ *((int *)&__m256_op16) = 0x80008000; ++ *((int *)&__m256_op15) = 0x80008000; ++ *((int *)&__m256_op14) = 0xfff98000; ++ *((int *)&__m256_op13) = 0x80008000; ++ *((int *)&__m256_op12) = 0x80008000; ++ *((int *)&__m256_op11) = 0x80008000; ++ *((int *)&__m256_op10) = 0xfff98000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000015d050192cb; ++ *((unsigned long *)&__m256d_op02) = 0x028e509508b16ee9; ++ *((unsigned long *)&__m256d_op01) = 0x000033ff01020e23; ++ *((unsigned long *)&__m256d_op00) = 0x151196b58fd1114d; ++ *((unsigned long *)&__m256d_op13) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256d_op12) = 0xc5c085372cfabfba; ++ *((unsigned long *)&__m256d_op11) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256d_op10) = 0x0658f2dc0eb21e3c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256d_op12) = 0x1e18000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256d_op10) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffff000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op12) = 0x0101010101010203; ++ *((unsigned long *)&__m256d_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00fe01f000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x00fe01f000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x000b000b000b000b; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000b000b000b000b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_cun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvfcmp-saf-seq-sl.patch
Added
@@ -0,0 +1,4824 @@ +From beaeb3f05a71c637d47a0e5f86f5781345e10f97 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:48:35 +0800 +Subject: PATCH 117/124 LoongArch: Add tests for ASX vector + xvfcmp{saf/seq/sle/slt/sne/sor/sun} instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_saf_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_seq_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sle_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_slt_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sne_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sor_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sun_s.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvfcmp_saf_s.c | 424 ++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_seq_s.c | 924 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_sle_s.c | 627 +++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_slt_s.c | 1212 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_sne_s.c | 756 ++++++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_sor_s.c | 438 ++++++ + .../loongarch/vector/lasx/lasx-xvfcmp_sun_s.c | 363 +++++ + 7 files changed, 4744 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_saf_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_seq_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sle_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_slt_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sne_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sor_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sun_s.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_saf_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_saf_s.c +new file mode 100644 +index 000000000..23cbc4bf0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_saf_s.c +@@ -0,0 +1,424 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0x0eb7aaaa; ++ *((int *)&__m256_op16) = 0xa6e6ac80; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x0eb7aaaa; ++ *((int *)&__m256_op12) = 0xa6e6ac80; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x3fff3fff; ++ *((int *)&__m256_op06) = 0x3fff3fff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x3fff3fff; ++ *((int *)&__m256_op03) = 0x3fff3fff; ++ *((int *)&__m256_op02) = 0x3fff3fff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x3fff3fff; ++ *((int *)&__m256_op17) = 0x017e01fe; ++ *((int *)&__m256_op16) = 0x01fe01fe; ++ *((int *)&__m256_op15) = 0x05860606; ++ *((int *)&__m256_op14) = 0x01fe0202; ++ *((int *)&__m256_op13) = 0x017e01fe; ++ *((int *)&__m256_op12) = 0x01fe0000; ++ *((int *)&__m256_op11) = 0x05860606; ++ *((int *)&__m256_op10) = 0x01fe0004; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000003f; ++ *((int *)&__m256_op06) = 0x00390035; ++ *((int *)&__m256_op05) = 0x8015003f; ++ *((int *)&__m256_op04) = 0x0006001f; ++ *((int *)&__m256_op03) = 0x0000003f; ++ *((int *)&__m256_op02) = 0x00390035; ++ *((int *)&__m256_op01) = 0x8015003f; ++ *((int *)&__m256_op00) = 0x0006001f; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xefdfefdf; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xefdfefdf; ++ *((int *)&__m256_op14) = 0xefdfefdf; ++ *((int *)&__m256_op13) = 0xefdfefdf; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xefdfefdf; ++ *((int *)&__m256_op10) = 0xefdfefdf; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00ff00ff; ++ *((int *)&__m256_op16) = 0x00ff00ff; ++ *((int *)&__m256_op15) = 0x00ff00ff; ++ *((int *)&__m256_op14) = 0x00ff00ff; ++ *((int *)&__m256_op13) = 0x00ff00ff; ++ *((int *)&__m256_op12) = 0x00ff00ff; ++ *((int *)&__m256_op11) = 0x00ff00ff; ++ *((int *)&__m256_op10) = 0x00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000001; ++ *((int *)&__m256_op06) = 0x7bfffff0; ++ *((int *)&__m256_op05) = 0x00000001; ++ *((int *)&__m256_op04) = 0x80007fe8; ++ *((int *)&__m256_op03) = 0x00000001; ++ *((int *)&__m256_op02) = 0x7bfffff0; ++ *((int *)&__m256_op01) = 0x00000001; ++ *((int *)&__m256_op00) = 0x80007fe8; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x02020102; ++ *((int *)&__m256_op06) = 0x02020102; ++ *((int *)&__m256_op05) = 0x02020102; ++ *((int *)&__m256_op04) = 0x02020102; ++ *((int *)&__m256_op03) = 0x02020102; ++ *((int *)&__m256_op02) = 0x02020102; ++ *((int *)&__m256_op01) = 0x02020102; ++ *((int *)&__m256_op00) = 0x02020102; ++ *((int *)&__m256_op17) = 0x3e800000; ++ *((int *)&__m256_op16) = 0x3e800000; ++ *((int *)&__m256_op15) = 0x3e800000; ++ *((int *)&__m256_op14) = 0x3e800000; ++ *((int *)&__m256_op13) = 0x3e800000; ++ *((int *)&__m256_op12) = 0x3e800000; ++ *((int *)&__m256_op11) = 0x3e800000; ++ *((int *)&__m256_op10) = 0x3e800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00ff00ff; ++ *((int *)&__m256_op06) = 0x00ff00ff; ++ *((int *)&__m256_op05) = 0x00ff00ff; ++ *((int *)&__m256_op04) = 0x00ff00ff; ++ *((int *)&__m256_op03) = 0x00ff00ff; ++ *((int *)&__m256_op02) = 0x00ff00ff; ++ *((int *)&__m256_op01) = 0x00ff00ff; ++ *((int *)&__m256_op00) = 0x00ff00ff; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x80000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xff88ff88; ++ *((int *)&__m256_op03) = 0x80000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xff88ff88; ++ *((int *)&__m256_op17) = 0xfe01fe01; ++ *((int *)&__m256_op16) = 0x0000fd02; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x3fc03fc0; ++ *((int *)&__m256_op13) = 0xfe01fe01; ++ *((int *)&__m256_op12) = 0x0000fd02; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x3fc03fc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000001; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0xffffb2f6; ++ *((int *)&__m256_op04) = 0x00006f48; ++ *((int *)&__m256_op03) = 0x00000001; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0xffffb2f6; ++ *((int *)&__m256_op00) = 0x00006f48; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x000000ff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00100010; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00100010; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00100010; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00100010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000020; ++ *((unsigned long *)&__m256d_op12) = 0x0020000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000020; ++ *((unsigned long *)&__m256d_op10) = 0x0020000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000010; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m256d_op13) = 0x000408080c111414; ++ *((unsigned long *)&__m256d_op12) = 0x000408080c111414; ++ *((unsigned long *)&__m256d_op11) = 0x000408080c111414; ++ *((unsigned long *)&__m256d_op10) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffb8579f; ++ *((unsigned long *)&__m256d_op01) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffb8579f; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000200000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000004000; ++ *((unsigned long *)&__m256d_op01) = 0x0000200000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000004000; ++ *((unsigned long *)&__m256d_op13) = 0x3fffbfff80000000; ++ *((unsigned long *)&__m256d_op12) = 0x00004000007f8000; ++ *((unsigned long *)&__m256d_op11) = 0x3fffbfff80000000; ++ *((unsigned long *)&__m256d_op10) = 0x00004000007f8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_saf_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_seq_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_seq_s.c +new file mode 100644 +index 000000000..6641d2c58 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_seq_s.c +@@ -0,0 +1,924 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x59800000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x59800000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x41d66000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x41d66000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xa41aa42e; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xa41aa42e; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x83f95466; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x01010101; ++ *((int *)&__m256_op00) = 0x00005400; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xfefefeff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xff295329; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xfefefeff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xff295329; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x111ebb78; ++ *((int *)&__m256_op16) = 0x4f9c4100; ++ *((int *)&__m256_op15) = 0x1c386546; ++ *((int *)&__m256_op14) = 0x809f3b50; ++ *((int *)&__m256_op13) = 0x111ebb78; ++ *((int *)&__m256_op12) = 0x4f9bf1ac; ++ *((int *)&__m256_op11) = 0x21f6050d; ++ *((int *)&__m256_op10) = 0x955d3f68; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffff0000; ++ *((int *)&__m256_op14) = 0xffff0001; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffff0000; ++ *((int *)&__m256_op10) = 0xffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000100; ++ *((int *)&__m256_op05) = 0x00000002; ++ *((int *)&__m256_op04) = 0xff910072; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000100; ++ *((int *)&__m256_op01) = 0x00000002; ++ *((int *)&__m256_op00) = 0xff910072; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffff97a2; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffff97a2; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_seq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x55555555; ++ *((int *)&__m256_op06) = 0x3f800000; ++ *((int *)&__m256_op05) = 0x55555555; ++ *((int *)&__m256_op04) = 0x80000000; ++ *((int *)&__m256_op03) = 0x55555555; ++ *((int *)&__m256_op02) = 0x3f800000; ++ *((int *)&__m256_op01) = 0x55555555; ++ *((int *)&__m256_op00) = 0x80000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x0001fffe; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x0001fffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00018002; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000002; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00018002; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000002; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00030000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00030000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xfff70156; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xfff70156; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xfff70156; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xfff70156; ++ *((int *)&__m256_op17) = 0x7fefffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0x7fefffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x7fefffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0x7fefffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000ff70; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000ff70; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000100; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000100; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000002; ++ *((int *)&__m256_op14) = 0x00000008; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000002; ++ *((int *)&__m256_op10) = 0x00000008; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x4393a0a5; ++ *((int *)&__m256_op06) = 0xbc606060; ++ *((int *)&__m256_op05) = 0x43b32fee; ++ *((int *)&__m256_op04) = 0xa9000000; ++ *((int *)&__m256_op03) = 0x4393a0a5; ++ *((int *)&__m256_op02) = 0xbc606060; ++ *((int *)&__m256_op01) = 0x43b32fee; ++ *((int *)&__m256_op00) = 0xa9000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000001; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000003; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000003; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000003; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000003; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfffeb664; ++ *((int *)&__m256_op06) = 0x007ffd61; ++ *((int *)&__m256_op05) = 0xfffe97a1; ++ *((int *)&__m256_op04) = 0xdf5b41b0; ++ *((int *)&__m256_op03) = 0xfffeb664; ++ *((int *)&__m256_op02) = 0x007ffd61; ++ *((int *)&__m256_op01) = 0xfffe97a1; ++ *((int *)&__m256_op00) = 0xdf5b41b0; ++ *((int *)&__m256_op17) = 0xfffeb683; ++ *((int *)&__m256_op16) = 0x9ffffd80; ++ *((int *)&__m256_op15) = 0xfffe97c0; ++ *((int *)&__m256_op14) = 0x20010001; ++ *((int *)&__m256_op13) = 0xfffeb683; ++ *((int *)&__m256_op12) = 0x9ffffd80; ++ *((int *)&__m256_op11) = 0xfffe97c0; ++ *((int *)&__m256_op10) = 0x20010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sueq_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x053531f7c6334908; ++ *((unsigned long *)&__m256d_op02) = 0x8e41dcbff87e7900; ++ *((unsigned long *)&__m256d_op01) = 0x12eb8332e3e15093; ++ *((unsigned long *)&__m256d_op00) = 0x9a7491f9e016ccd4; ++ *((unsigned long *)&__m256d_op13) = 0x345947dcd192b5c4; ++ *((unsigned long *)&__m256d_op12) = 0x182100c72280e687; ++ *((unsigned long *)&__m256d_op11) = 0x4a1c80bb8e892e00; ++ *((unsigned long *)&__m256d_op10) = 0x063ecfbd58abc4b7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffff0002fffeffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffff0002fffeffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x000000010486048c; ++ *((unsigned long *)&__m256d_op12) = 0x0000000100000006; ++ *((unsigned long *)&__m256d_op11) = 0x000000010486048c; ++ *((unsigned long *)&__m256d_op10) = 0x0000000100000006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256d_op02) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256d_op01) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256d_op00) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256d_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256d_op12) = 0x00ff00ff00ef0120; ++ *((unsigned long *)&__m256d_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256d_op10) = 0x00ff00ff00ef0120; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xff00ffff00000001; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op01) = 0xff00ffff00000001; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x04e8296f08181818; ++ *((unsigned long *)&__m256d_op12) = 0x032feea900000000; ++ *((unsigned long *)&__m256d_op11) = 0x04e8296f08181818; ++ *((unsigned long *)&__m256d_op10) = 0x032feea900000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x1400080008000000; ++ *((unsigned long *)&__m256d_op02) = 0x1400080008000000; ++ *((unsigned long *)&__m256d_op01) = 0x1400080008000000; ++ *((unsigned long *)&__m256d_op00) = 0x1400080008000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_seq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x000000000000ff80; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256d_op02) = 0x41d8585858400000; ++ *((unsigned long *)&__m256d_op01) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256d_op00) = 0x41d8585858400000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffff040000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0xffff040000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256d_op12) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256d_op11) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256d_op10) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffe045fffffeff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffff7d; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sueq_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sle_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sle_s.c +new file mode 100644 +index 000000000..d25fc25da +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sle_s.c +@@ -0,0 +1,627 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffff90; ++ *((int *)&__m256_op04) = 0xffffff80; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffff90; ++ *((int *)&__m256_op00) = 0xffffff80; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfefee0e3; ++ *((int *)&__m256_op06) = 0xfefefe00; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0xfefee0e3; ++ *((int *)&__m256_op02) = 0xfefefe00; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000ffff; ++ *((int *)&__m256_op06) = 0x0000ffff; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x0000ffff; ++ *((int *)&__m256_op02) = 0x0000ffff; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x8000000a; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x8000000a; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x01010101; ++ *((int *)&__m256_op06) = 0x01010101; ++ *((int *)&__m256_op05) = 0x01010101; ++ *((int *)&__m256_op04) = 0x01010101; ++ *((int *)&__m256_op03) = 0x01010101; ++ *((int *)&__m256_op02) = 0x01010101; ++ *((int *)&__m256_op01) = 0x01010101; ++ *((int *)&__m256_op00) = 0x01010101; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffd8ffc7; ++ *((int *)&__m256_op04) = 0xffdaff8a; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffd8ffc7; ++ *((int *)&__m256_op00) = 0xffdaff8a; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0xffffb3b4; ++ *((int *)&__m256_op15) = 0xfffffff5; ++ *((int *)&__m256_op14) = 0xffff4738; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0xffffb3b4; ++ *((int *)&__m256_op11) = 0xfffffff5; ++ *((int *)&__m256_op10) = 0xffff4738; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xf7f7f7f7; ++ *((int *)&__m256_op16) = 0xf7f7f7f8; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xf7f7f7f7; ++ *((int *)&__m256_op12) = 0xf7f7f7f8; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x5fa00000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x5fa00000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256d_op02) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256d_op01) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256d_op00) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256d_op13) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256d_op12) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256d_op11) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256d_op10) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000105fffffefb; ++ *((unsigned long *)&__m256d_op02) = 0xffffff02000000fe; ++ *((unsigned long *)&__m256d_op01) = 0x00000105fffffefb; ++ *((unsigned long *)&__m256d_op00) = 0xffffff02000000fe; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00000000000000fe; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000020afefb1; ++ *((unsigned long *)&__m256d_op02) = 0x7f350104f7ebffff; ++ *((unsigned long *)&__m256d_op01) = 0x00000000003fffc1; ++ *((unsigned long *)&__m256d_op00) = 0x005c0003fff9ffff; ++ *((unsigned long *)&__m256d_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256d_op12) = 0x0209fefb08140000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_op13) = 0x00000003f8000004; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x00000003f8000004; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000003; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000003; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000003; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256d_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256d_op13) = 0x8000800080008000; ++ *((unsigned long *)&__m256d_op12) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256d_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m256d_op10) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000010100000101; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000010100000101; ++ *((unsigned long *)&__m256d_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256d_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256d_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256d_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256d_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256d_op13) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256d_op12) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256d_op11) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256d_op10) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256d_op13) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffe0ffe000000000; ++ *((unsigned long *)&__m256d_op11) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffe0ffe000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sle_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfc00000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xfc00000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xfc00000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xfc00000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xf5f5f5f5f5f5f5f5; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xf5f5f5f5f5f5f5f5; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x8d8d72728d8d7272; ++ *((unsigned long *)&__m256d_op02) = 0x8d8d72728d8d8d8d; ++ *((unsigned long *)&__m256d_op01) = 0x8d8d72728d8d7272; ++ *((unsigned long *)&__m256d_op00) = 0x8d8d72728d8d8d8d; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffff010100000001; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffff010100000001; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sule_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_slt_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_slt_s.c +new file mode 100644 +index 000000000..8210f749b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_slt_s.c +@@ -0,0 +1,1212 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000101; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xc08f7800; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xfffffefd; ++ *((int *)&__m256_op03) = 0xc08f7800; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000101; ++ *((int *)&__m256_op14) = 0x00000102; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000101; ++ *((int *)&__m256_op10) = 0x00000102; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x001f1f3e; ++ *((int *)&__m256_op16) = 0x3e1f1f00; ++ *((int *)&__m256_op15) = 0x00030609; ++ *((int *)&__m256_op14) = 0x09060300; ++ *((int *)&__m256_op13) = 0x001f1f3e; ++ *((int *)&__m256_op12) = 0x3e1f1f00; ++ *((int *)&__m256_op11) = 0x00030609; ++ *((int *)&__m256_op10) = 0x09060300; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000001; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000001; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x7fffffff; ++ *((int *)&__m256_op06) = 0x7fffffff; ++ *((int *)&__m256_op05) = 0x7fffffff; ++ *((int *)&__m256_op04) = 0x7fffffff; ++ *((int *)&__m256_op03) = 0x7fffffff; ++ *((int *)&__m256_op02) = 0x7fffffff; ++ *((int *)&__m256_op01) = 0x7fffffff; ++ *((int *)&__m256_op00) = 0x7fffffff; ++ *((int *)&__m256_op17) = 0x20fc0000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x20fc0000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffff0400; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xffff0400; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x08050501; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x08050501; ++ *((int *)&__m256_op17) = 0x90909090; ++ *((int *)&__m256_op16) = 0x90909090; ++ *((int *)&__m256_op15) = 0x90909090; ++ *((int *)&__m256_op14) = 0x90909090; ++ *((int *)&__m256_op13) = 0x90909090; ++ *((int *)&__m256_op12) = 0x90909090; ++ *((int *)&__m256_op11) = 0x90909090; ++ *((int *)&__m256_op10) = 0x90909090; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00001ff8; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xd8d8c000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00001ff8; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xd8d8c000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x02020102; ++ *((int *)&__m256_op16) = 0x02020102; ++ *((int *)&__m256_op15) = 0x02020102; ++ *((int *)&__m256_op14) = 0x02020102; ++ *((int *)&__m256_op13) = 0x02020102; ++ *((int *)&__m256_op12) = 0x02020102; ++ *((int *)&__m256_op11) = 0x02020102; ++ *((int *)&__m256_op10) = 0x02020102; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00ff00ff; ++ *((int *)&__m256_op06) = 0x00ff00ff; ++ *((int *)&__m256_op05) = 0x00ff00ff; ++ *((int *)&__m256_op04) = 0x00ff00ff; ++ *((int *)&__m256_op03) = 0x00ff00ff; ++ *((int *)&__m256_op02) = 0x00ff00ff; ++ *((int *)&__m256_op01) = 0x00ff00ff; ++ *((int *)&__m256_op00) = 0x00ff00ff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000001; ++ *((int *)&__m256_op16) = 0xffe00000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000001; ++ *((int *)&__m256_op12) = 0xffe00000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x60000108; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x01060005; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x7fef0001; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xfffffff8; ++ *((int *)&__m256_op14) = 0xfffffff8; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xfffffff8; ++ *((int *)&__m256_op10) = 0xfc000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x327f0101; ++ *((int *)&__m256_op06) = 0x01010102; ++ *((int *)&__m256_op05) = 0x63000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x327f0101; ++ *((int *)&__m256_op02) = 0x01010102; ++ *((int *)&__m256_op01) = 0x63000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xce7fffff; ++ *((int *)&__m256_op16) = 0xfffffffe; ++ *((int *)&__m256_op15) = 0x63000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xce7fffff; ++ *((int *)&__m256_op12) = 0xfffffffe; ++ *((int *)&__m256_op11) = 0x63000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x59800000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x59800000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x0eb7aaaa; ++ *((int *)&__m256_op16) = 0xa6e6ac80; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x0eb7aaaa; ++ *((int *)&__m256_op12) = 0xa6e6ac80; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000007; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xdbc80000; ++ *((int *)&__m256_op16) = 0x00003fff; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xdbc80000; ++ *((int *)&__m256_op12) = 0x00003fff; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000002; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000007f; ++ *((int *)&__m256_op17) = 0xfffffff3; ++ *((int *)&__m256_op16) = 0x0000000b; ++ *((int *)&__m256_op15) = 0xfffffff3; ++ *((int *)&__m256_op14) = 0xfffffff3; ++ *((int *)&__m256_op13) = 0xfffffff3; ++ *((int *)&__m256_op12) = 0x0000000b; ++ *((int *)&__m256_op11) = 0xfffffff3; ++ *((int *)&__m256_op10) = 0xfffffff3; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x223d76f0; ++ *((int *)&__m256_op06) = 0x9f3881ff; ++ *((int *)&__m256_op05) = 0x3870ca8d; ++ *((int *)&__m256_op04) = 0x013e76a0; ++ *((int *)&__m256_op03) = 0x223d76f0; ++ *((int *)&__m256_op02) = 0x9f37e357; ++ *((int *)&__m256_op01) = 0x43ec0a1b; ++ *((int *)&__m256_op00) = 0x2aba7ed0; ++ *((int *)&__m256_op17) = 0x111ebb78; ++ *((int *)&__m256_op16) = 0x4f9c4100; ++ *((int *)&__m256_op15) = 0x1c386546; ++ *((int *)&__m256_op14) = 0x809f3b50; ++ *((int *)&__m256_op13) = 0x111ebb78; ++ *((int *)&__m256_op12) = 0x4f9bf1ac; ++ *((int *)&__m256_op11) = 0x21f6050d; ++ *((int *)&__m256_op10) = 0x955d3f68; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x01010101; ++ *((int *)&__m256_op06) = 0x27272525; ++ *((int *)&__m256_op05) = 0x23a2a121; ++ *((int *)&__m256_op04) = 0x179e951d; ++ *((int *)&__m256_op03) = 0x01010101; ++ *((int *)&__m256_op02) = 0x27272525; ++ *((int *)&__m256_op01) = 0x23a2a121; ++ *((int *)&__m256_op00) = 0x179e951d; ++ *((int *)&__m256_op17) = 0x00001251; ++ *((int *)&__m256_op16) = 0x00005111; ++ *((int *)&__m256_op15) = 0x00000c4f; ++ *((int *)&__m256_op14) = 0x00004b0f; ++ *((int *)&__m256_op13) = 0x00001251; ++ *((int *)&__m256_op12) = 0x00005111; ++ *((int *)&__m256_op11) = 0x00000c4f; ++ *((int *)&__m256_op10) = 0x00004b0f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x80000000; ++ *((int *)&__m256_op16) = 0xff800000; ++ *((int *)&__m256_op15) = 0x80000000; ++ *((int *)&__m256_op14) = 0x80000000; ++ *((int *)&__m256_op13) = 0x80000000; ++ *((int *)&__m256_op12) = 0xff800000; ++ *((int *)&__m256_op11) = 0x80000000; ++ *((int *)&__m256_op10) = 0x80000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_op17) = 0x7ff00000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x7ff00000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x7ff00000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x7ff00000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x000000ff; ++ *((int *)&__m256_op16) = 0x000000ff; ++ *((int *)&__m256_op15) = 0x000000ff; ++ *((int *)&__m256_op14) = 0x000000ff; ++ *((int *)&__m256_op13) = 0x000000ff; ++ *((int *)&__m256_op12) = 0x000000ff; ++ *((int *)&__m256_op11) = 0x000000ff; ++ *((int *)&__m256_op10) = 0x000000ff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xfe01fe01; ++ *((int *)&__m256_op06) = 0x7e81fd02; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x3fc001fe; ++ *((int *)&__m256_op03) = 0xfe01fe01; ++ *((int *)&__m256_op02) = 0x7e81fd02; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x3fc001fe; ++ *((int *)&__m256_op17) = 0xfe01fe01; ++ *((int *)&__m256_op16) = 0x7e81fd02; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x3fc001fe; ++ *((int *)&__m256_op13) = 0xfe01fe01; ++ *((int *)&__m256_op12) = 0x7e81fd02; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x3fc001fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x80000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x80000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x80000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x80000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0ff80100ffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0ff80100ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000017000000080; ++ *((unsigned long *)&__m256d_op12) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256d_op11) = 0x0000017000000080; ++ *((unsigned long *)&__m256d_op10) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x01480000052801a2; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffdcff64; ++ *((unsigned long *)&__m256d_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op12) = 0x0101010101010203; ++ *((unsigned long *)&__m256d_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffff000100000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000fe0100000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000fe0100000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000001900000019; ++ *((unsigned long *)&__m256d_op12) = 0x0000001900000019; ++ *((unsigned long *)&__m256d_op11) = 0x0000001900000019; ++ *((unsigned long *)&__m256d_op10) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x000000007fffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x000000007fffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256d_op02) = 0x00000fff00004542; ++ *((unsigned long *)&__m256d_op01) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256d_op00) = 0x00000fff00004542; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256d_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256d_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256d_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00aa00ab00ff00ff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00aa00ab00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256d_op13) = 0xffe37fe3001d001d; ++ *((unsigned long *)&__m256d_op12) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256d_op11) = 0xffe37fe3001d001d; ++ *((unsigned long *)&__m256d_op10) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffa30000165a; ++ *((unsigned long *)&__m256d_op02) = 0x0000104000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffa30000165a; ++ *((unsigned long *)&__m256d_op00) = 0x0000104000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256d_op12) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256d_op11) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256d_op10) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00003fe000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x000000430207f944; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfe01fe017e81fd02; ++ *((unsigned long *)&__m256d_op02) = 0x000000003fc001fe; ++ *((unsigned long *)&__m256d_op01) = 0xfe01fe017e81fd02; ++ *((unsigned long *)&__m256d_op00) = 0x000000003fc001fe; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_slt_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffff000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00000000000000fe; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000003868686a20; ++ *((unsigned long *)&__m256d_op12) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256d_op11) = 0x0000003868686a20; ++ *((unsigned long *)&__m256d_op10) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256d_op02) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xfffff8d9ffa7103d; ++ *((unsigned long *)&__m256d_op13) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256d_op12) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xfffff8d9ffa7103d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000008; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000080000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000b004a00440040; ++ *((unsigned long *)&__m256d_op02) = 0x8020004a0011002a; ++ *((unsigned long *)&__m256d_op01) = 0x000b004a00440040; ++ *((unsigned long *)&__m256d_op00) = 0x8020004a0011002a; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0fff0fff00000020; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0fff0fff00000020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0002000000020000; ++ *((unsigned long *)&__m256d_op02) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m256d_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256d_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256d_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256d_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256d_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op12) = 0x0002000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256d_op10) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000ff00000000; ++ *((unsigned long *)&__m256d_op02) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x000000ff00000000; ++ *((unsigned long *)&__m256d_op00) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xfffefffefffeffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xfffefffefffeffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000860601934; ++ *((unsigned long *)&__m256d_op02) = 0x0000000800200028; ++ *((unsigned long *)&__m256d_op01) = 0x0000000860601934; ++ *((unsigned long *)&__m256d_op00) = 0x0000000800200028; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256d_op12) = 0x4079808280057efe; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x007ffcfcfd020202; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000400000004; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000400000004; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sult_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sne_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sne_s.c +new file mode 100644 +index 000000000..9d015a5c8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sne_s.c +@@ -0,0 +1,756 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x80808080; ++ *((int *)&__m256_op06) = 0x80808080; ++ *((int *)&__m256_op05) = 0x80808080; ++ *((int *)&__m256_op04) = 0x80808080; ++ *((int *)&__m256_op03) = 0x80808080; ++ *((int *)&__m256_op02) = 0x80808080; ++ *((int *)&__m256_op01) = 0x80808080; ++ *((int *)&__m256_op00) = 0x80808080; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xefefefef; ++ *((int *)&__m256_op06) = 0xefefefef; ++ *((int *)&__m256_op05) = 0xefefefef; ++ *((int *)&__m256_op04) = 0xefefefef; ++ *((int *)&__m256_op03) = 0xefefefef; ++ *((int *)&__m256_op02) = 0xefefef6e; ++ *((int *)&__m256_op01) = 0xeeeeeeee; ++ *((int *)&__m256_op00) = 0xeeeeeeee; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x7f800000; ++ *((int *)&__m256_op06) = 0x7f800000; ++ *((int *)&__m256_op05) = 0x7f800000; ++ *((int *)&__m256_op04) = 0x7f800000; ++ *((int *)&__m256_op03) = 0x7f800000; ++ *((int *)&__m256_op02) = 0x7f800000; ++ *((int *)&__m256_op01) = 0x7f800000; ++ *((int *)&__m256_op00) = 0x7f800000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0x00ff00ff; ++ *((int *)&__m256_op16) = 0x00ff00ff; ++ *((int *)&__m256_op15) = 0x00ff00ff; ++ *((int *)&__m256_op14) = 0x00ff00ff; ++ *((int *)&__m256_op13) = 0x00ff00ff; ++ *((int *)&__m256_op12) = 0x00ff00ff; ++ *((int *)&__m256_op11) = 0x00ff00ff; ++ *((int *)&__m256_op10) = 0x00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x80000000; ++ *((int *)&__m256_op14) = 0x80000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x80000000; ++ *((int *)&__m256_op10) = 0x80000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x40404040; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x40404040; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0xfefefefe; ++ *((int *)&__m256_op14) = 0x3f800000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0xfefefefe; ++ *((int *)&__m256_op10) = 0x3f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffff0101; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffff0101; ++ *((int *)&__m256_op00) = 0x00000001; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x01010101; ++ *((int *)&__m256_op05) = 0x55555501; ++ *((int *)&__m256_op04) = 0xfefefeab; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x01010101; ++ *((int *)&__m256_op01) = 0x55555501; ++ *((int *)&__m256_op00) = 0xfefefeab; ++ *((int *)&__m256_op17) = 0x0010bfc8; ++ *((int *)&__m256_op16) = 0x0010bf52; ++ *((int *)&__m256_op15) = 0xfff1bfca; ++ *((int *)&__m256_op14) = 0x0011bfcb; ++ *((int *)&__m256_op13) = 0x0010bfc8; ++ *((int *)&__m256_op12) = 0x0010bf52; ++ *((int *)&__m256_op11) = 0xfff1bfca; ++ *((int *)&__m256_op10) = 0x0011bfcb; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x80008000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x80008000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x80008000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x80008000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00060000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00060000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000166; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000166; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0000004a; ++ *((int *)&__m256_op06) = 0x557baac4; ++ *((int *)&__m256_op05) = 0x556caad9; ++ *((int *)&__m256_op04) = 0xaabbaa88; ++ *((int *)&__m256_op03) = 0x0000004a; ++ *((int *)&__m256_op02) = 0x557baac4; ++ *((int *)&__m256_op01) = 0x556caad9; ++ *((int *)&__m256_op00) = 0xaabbaa88; ++ *((int *)&__m256_op17) = 0x09090909; ++ *((int *)&__m256_op16) = 0x09090909; ++ *((int *)&__m256_op15) = 0x09090909; ++ *((int *)&__m256_op14) = 0x09090909; ++ *((int *)&__m256_op13) = 0x09090909; ++ *((int *)&__m256_op12) = 0x09090909; ++ *((int *)&__m256_op11) = 0x09090909; ++ *((int *)&__m256_op10) = 0x09090909; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x80000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x80000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x80000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x80000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x80000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x80000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x80000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x80000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000020; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000020; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sune_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xbabababababababa; ++ *((unsigned long *)&__m256d_op02) = 0xbabababababababa; ++ *((unsigned long *)&__m256d_op01) = 0xbabababababababa; ++ *((unsigned long *)&__m256d_op00) = 0xbabababababababa; ++ *((unsigned long *)&__m256d_op13) = 0x88888a6d0962002e; ++ *((unsigned long *)&__m256d_op12) = 0xdb8a3109fe0f0020; ++ *((unsigned long *)&__m256d_op11) = 0x0000007fff01fffb; ++ *((unsigned long *)&__m256d_op10) = 0xdb8e20990cce025a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256d_op02) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256d_op01) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256d_op00) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256d_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256d_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256d_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sne_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xff00000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000000000fe; ++ *((unsigned long *)&__m256d_op01) = 0xff00000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000000000fe; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xfffffffffffebeb8; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xfffffffffffebeb8; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xfafafafafafafafa; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000fefefe; ++ *((unsigned long *)&__m256d_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op12) = 0x0101010101010203; ++ *((unsigned long *)&__m256d_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffee0000ff4c; ++ *((unsigned long *)&__m256d_op02) = 0x0000ff050000ff3c; ++ *((unsigned long *)&__m256d_op01) = 0x0000fff90000ff78; ++ *((unsigned long *)&__m256d_op00) = 0x0000ffa80000ff31; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0020002000200020; ++ *((unsigned long *)&__m256d_op12) = 0x0020000000200000; ++ *((unsigned long *)&__m256d_op11) = 0x0020002000200020; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256d_op02) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256d_op01) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256d_op00) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256d_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x0100000001000100; ++ *((unsigned long *)&__m256d_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0f00204000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0f00204000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000000a0008; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000000a0008; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x000000010000685e; ++ *((unsigned long *)&__m256d_op02) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256d_op01) = 0x000000010000685e; ++ *((unsigned long *)&__m256d_op00) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256d_op13) = 0x0087ff87f807ff87; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0087ff87f807ff87; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256d_op12) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256d_op11) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256d_op10) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256d_op12) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256d_op11) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256d_op10) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sune_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sor_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sor_s.c +new file mode 100644 +index 000000000..a61681073 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sor_s.c +@@ -0,0 +1,438 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000001; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000001; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x80000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x000000ff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x000000ff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000064; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000781; ++ *((int *)&__m256_op00) = 0x00000064; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x0c6a2400; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x0f002040; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x0c6a2400; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x0f002040; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x0000000c; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x0000000c; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0feff00000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0feff00000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000003868686a20; ++ *((unsigned long *)&__m256d_op12) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256d_op11) = 0x0000003868686a20; ++ *((unsigned long *)&__m256d_op10) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op12) = 0x3ff1808001020101; ++ *((unsigned long *)&__m256d_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256d_op10) = 0x3ff1808001020101; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000005; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000005; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000005; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000005; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256d_op02) = 0xfefefefeffe0e0e0; ++ *((unsigned long *)&__m256d_op01) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256d_op00) = 0xfefefefeffe0e0e0; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000040004000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op12) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op11) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256d_op10) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256d_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sor_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sun_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sun_s.c +new file mode 100644 +index 000000000..41f274920 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfcmp_sun_s.c +@@ -0,0 +1,363 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x1e180000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x1e180000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x1e180000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x1e180000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00802000; ++ *((int *)&__m256_op16) = 0x00802000; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x00802000; ++ *((int *)&__m256_op12) = 0x00802000; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000055; ++ *((int *)&__m256_op06) = 0x36aaaaac; ++ *((int *)&__m256_op05) = 0x55555555; ++ *((int *)&__m256_op04) = 0xaaaaaaac; ++ *((int *)&__m256_op03) = 0x00000055; ++ *((int *)&__m256_op02) = 0x36aaaaac; ++ *((int *)&__m256_op01) = 0x55555555; ++ *((int *)&__m256_op00) = 0xaaaaaaac; ++ *((int *)&__m256_op17) = 0x00060000; ++ *((int *)&__m256_op16) = 0x00040000; ++ *((int *)&__m256_op15) = 0x00025555; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00060000; ++ *((int *)&__m256_op12) = 0x00040000; ++ *((int *)&__m256_op11) = 0x00025555; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xff240000; ++ *((int *)&__m256_op06) = 0x0000ff00; ++ *((int *)&__m256_op05) = 0xfffeffe4; ++ *((int *)&__m256_op04) = 0xfffeff00; ++ *((int *)&__m256_op03) = 0xff640000; ++ *((int *)&__m256_op02) = 0x0000ff00; ++ *((int *)&__m256_op01) = 0xfffeff66; ++ *((int *)&__m256_op00) = 0xfffeff00; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x80808082; ++ *((int *)&__m256_op06) = 0x80808082; ++ *((int *)&__m256_op05) = 0x80808082; ++ *((int *)&__m256_op04) = 0x80808082; ++ *((int *)&__m256_op03) = 0x80808082; ++ *((int *)&__m256_op02) = 0x80808080; ++ *((int *)&__m256_op01) = 0x80808082; ++ *((int *)&__m256_op00) = 0x80808082; ++ *((int *)&__m256_op17) = 0x55555555; ++ *((int *)&__m256_op16) = 0x55555555; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x55555555; ++ *((int *)&__m256_op12) = 0x55555555; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x6d6d6d6d; ++ *((int *)&__m256_op06) = 0x6d6d6d6d; ++ *((int *)&__m256_op05) = 0x6d6d6d6d; ++ *((int *)&__m256_op04) = 0x6d6d6d6d; ++ *((int *)&__m256_op03) = 0x6d6d6d6d; ++ *((int *)&__m256_op02) = 0x6d6d6d6d; ++ *((int *)&__m256_op01) = 0x6d6d6d6d; ++ *((int *)&__m256_op00) = 0x6d6d6d6d; ++ *((int *)&__m256_op17) = 0x6d6d6d6d; ++ *((int *)&__m256_op16) = 0x6d6d6d6d; ++ *((int *)&__m256_op15) = 0x6d6d6d6d; ++ *((int *)&__m256_op14) = 0x6d6d6d6d; ++ *((int *)&__m256_op13) = 0x6d6d6d6d; ++ *((int *)&__m256_op12) = 0x6d6d6d6d; ++ *((int *)&__m256_op11) = 0x6d6d6d6d; ++ *((int *)&__m256_op10) = 0x6d6d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_s (__m256_op0, __m256_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256d_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256d_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256d_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000118; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000118; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256d_op12) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256d_op11) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256d_op10) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfcmp_sun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000027; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000027; ++ *((unsigned long *)&__m256d_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfcmp_sun_d (__m256d_op0, __m256d_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvfnmadd-xvfrstp-.patch
Added
@@ -0,0 +1,4991 @@ +From d0108f9375bd6eede5f7f4e289dce580b180848d Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:22:49 +0800 +Subject: PATCH 114/124 LoongArch: Add tests for ASX vector + xvfnmadd/xvfrstp/xvfstpi/xvhsubw/ xvmsub/xvrotr/xvrotri/xvld/xvst + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_d.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_s.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfrstp.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvfrstpi.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvhsubw-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvhsubw-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvld.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmsub.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvrotr.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvrotri.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvst.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvfnmadd_d.c | 324 +++++++ + .../loongarch/vector/lasx/lasx-xvfnmadd_s.c | 895 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvfrstp.c | 381 ++++++++ + .../loongarch/vector/lasx/lasx-xvfrstpi.c | 350 +++++++ + .../loongarch/vector/lasx/lasx-xvhsubw-1.c | 620 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvhsubw-2.c | 545 +++++++++++ + .../loongarch/vector/lasx/lasx-xvld.c | 86 ++ + .../loongarch/vector/lasx/lasx-xvmsub.c | 647 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvrotr.c | 530 +++++++++++ + .../loongarch/vector/lasx/lasx-xvrotri.c | 394 ++++++++ + .../loongarch/vector/lasx/lasx-xvst.c | 102 ++ + 11 files changed, 4874 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstp.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstpi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvld.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsub.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotri.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvst.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_d.c +new file mode 100644 +index 000000000..d161c850c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_d.c +@@ -0,0 +1,324 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0001010101010101; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000010100; ++ *((unsigned long *)&__m256d_op10) = 0x0001000001000100; ++ *((unsigned long *)&__m256d_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op22) = 0xffffffffbf7f7fff; ++ *((unsigned long *)&__m256d_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op20) = 0xffffffffe651bfff; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffbf7f7fff; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffe651bfff; ++ __m256d_out = __lasx_xvfnmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x3ff73ff83ff73ff8; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x3ff73ff83ff73ff8; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x2020202020202020; ++ *((unsigned long *)&__m256d_op22) = 0x2020202020206431; ++ *((unsigned long *)&__m256d_op21) = 0x2020202020202020; ++ *((unsigned long *)&__m256d_op20) = 0x2020202020206431; ++ *((unsigned long *)&__m256d_result3) = 0xa020202020202020; ++ *((unsigned long *)&__m256d_result2) = 0xa020202020206431; ++ *((unsigned long *)&__m256d_result1) = 0xa020202020202020; ++ *((unsigned long *)&__m256d_result0) = 0xa020202020206431; ++ __m256d_out = __lasx_xvfnmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256d_op02) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256d_op01) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256d_op00) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256d_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op23) = 0x0001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256d_op22) = 0x7f7f7f5c8f374980; ++ *((unsigned long *)&__m256d_op21) = 0x0001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256d_op20) = 0x7f7f7f5c8f374980; ++ *((unsigned long *)&__m256d_result3) = 0x8001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0x8001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfnmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xff21ff21ff21ff21; ++ *((unsigned long *)&__m256d_op02) = 0xff21ff21ff21ff21; ++ *((unsigned long *)&__m256d_op01) = 0xff21ff21ff21ff21; ++ *((unsigned long *)&__m256d_op00) = 0xff21ff21ff21ff21; ++ *((unsigned long *)&__m256d_op13) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256d_op12) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256d_op11) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256d_op10) = 0xff21c241ff21c241; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xfff0000000000000; ++ __m256d_out = __lasx_xvfnmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000007; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000000000; ++ __m256d_out = __lasx_xvfnmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x1080108010060002; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x1080108010060002; ++ *((unsigned long *)&__m256d_op13) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256d_op12) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256d_op11) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256d_op10) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m256d_op23) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256d_op22) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256d_op21) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256d_op20) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256d_result3) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256d_result2) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256d_result1) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256d_result0) = 0x7fff00017fff0000; ++ __m256d_out = __lasx_xvfnmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x1716151417161514; ++ *((unsigned long *)&__m256d_op02) = 0x1716151417161514; ++ *((unsigned long *)&__m256d_op01) = 0x1716151417161514; ++ *((unsigned long *)&__m256d_op00) = 0x1716151417161514; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000002780; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000002780; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000002780; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000002780; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000002780; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000002780; ++ __m256d_out = __lasx_xvfnmadd_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0080200000802000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0080200000802000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0080200000802000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op11) = 0x0080200000802000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffffffff; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000000000; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256d_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256d_op01) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256d_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0xffffffffffba0c05; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0xffffffffffba0c05; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000483800; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000483800; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000483800; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffffba0c05; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000483800; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffffba0c05; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x000000007fffffff; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000000000; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000005000000020; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000005000000020; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000005000000020; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000005000000020; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000005000000020; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000005000000020; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0000005000000020; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0000005000000020; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x0010000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0008000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0010000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0008000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0010000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x0008000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0010000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x0008000000000000; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xff0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256d_op02) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256d_op01) = 0xff0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256d_op00) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256d_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000000000; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_op02) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_op01) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_op00) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_op13) = 0xffff801000000010; ++ *((unsigned long *)&__m256d_op12) = 0xffff800300000000; ++ *((unsigned long *)&__m256d_op11) = 0xffff801000000010; ++ *((unsigned long *)&__m256d_op10) = 0xffff800300000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result2) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256d_result0) = 0xffffffffe0000000; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ *((unsigned long *)&__m256d_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op02) = 0x00000000ffffffce; ++ *((unsigned long *)&__m256d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op00) = 0x00000000ffffffce; ++ *((unsigned long *)&__m256d_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op12) = 0x0000000700000000; ++ *((unsigned long *)&__m256d_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256d_op10) = 0x0000000700000000; ++ *((unsigned long *)&__m256d_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256d_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256d_result0) = 0x8000000000000000; ++ __m256d_out = __lasx_xvfnmsub_d (__m256d_op0, __m256d_op1, __m256d_op2); ++ ASSERTEQ_64 (__LINE__, __m256d_result, __m256d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_s.c +new file mode 100644 +index 000000000..c5e9576ea +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfnmadd_s.c +@@ -0,0 +1,895 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffffff; ++ *((int *)&__m256_op16) = 0xffff5f5c; ++ *((int *)&__m256_op15) = 0xffffffff; ++ *((int *)&__m256_op14) = 0xffff5f5c; ++ *((int *)&__m256_op13) = 0xffffffff; ++ *((int *)&__m256_op12) = 0xffff5f5c; ++ *((int *)&__m256_op11) = 0xffffffff; ++ *((int *)&__m256_op10) = 0xffff5f5c; ++ *((int *)&__m256_op27) = 0x0000000f; ++ *((int *)&__m256_op26) = 0x0000000f; ++ *((int *)&__m256_op25) = 0xff00ff0f; ++ *((int *)&__m256_op24) = 0xff005f0f; ++ *((int *)&__m256_op23) = 0x0000000f; ++ *((int *)&__m256_op22) = 0x0000000f; ++ *((int *)&__m256_op21) = 0xff00ff0f; ++ *((int *)&__m256_op20) = 0xff005f0f; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffff5f5c; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffff5f5c; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffff5f5c; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffff5f5c; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00010001; ++ *((int *)&__m256_op06) = 0x00010000; ++ *((int *)&__m256_op05) = 0x020afefb; ++ *((int *)&__m256_op04) = 0x08140000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000001; ++ *((int *)&__m256_op01) = 0x0003fffc; ++ *((int *)&__m256_op00) = 0x00060000; ++ *((int *)&__m256_op17) = 0x80000000; ++ *((int *)&__m256_op16) = 0x40000000; ++ *((int *)&__m256_op15) = 0x40000000; ++ *((int *)&__m256_op14) = 0x10000010; ++ *((int *)&__m256_op13) = 0x80000000; ++ *((int *)&__m256_op12) = 0x40000000; ++ *((int *)&__m256_op11) = 0x80000000; ++ *((int *)&__m256_op10) = 0x40000010; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x000000ff; ++ *((int *)&__m256_op24) = 0x0001ffff; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x0000ffff; ++ *((int *)&__m256_op20) = 0x00010000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80020000; ++ *((int *)&__m256_result5) = 0x828aff0b; ++ *((int *)&__m256_result4) = 0x8001ffff; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000002; ++ *((int *)&__m256_result1) = 0x8000ffff; ++ *((int *)&__m256_result0) = 0x800d0002; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x1f3d2101; ++ *((int *)&__m256_op06) = 0x1f3d2101; ++ *((int *)&__m256_op05) = 0x1f3d2101; ++ *((int *)&__m256_op04) = 0xd07dbf01; ++ *((int *)&__m256_op03) = 0x9f1fd080; ++ *((int *)&__m256_op02) = 0x1f3d2101; ++ *((int *)&__m256_op01) = 0x1f3d2101; ++ *((int *)&__m256_op00) = 0xd07dbf01; ++ *((int *)&__m256_op17) = 0x1d949d94; ++ *((int *)&__m256_op16) = 0x9d949d95; ++ *((int *)&__m256_op15) = 0x1d949d94; ++ *((int *)&__m256_op14) = 0x9e1423d4; ++ *((int *)&__m256_op13) = 0x1de9a03f; ++ *((int *)&__m256_op12) = 0x3dd41d95; ++ *((int *)&__m256_op11) = 0x1d949d94; ++ *((int *)&__m256_op10) = 0x9e1423d4; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x8001b72e; ++ *((int *)&__m256_result6) = 0x0001b72e; ++ *((int *)&__m256_result5) = 0x8001b72e; ++ *((int *)&__m256_result4) = 0xaf12d5f0; ++ *((int *)&__m256_result3) = 0x00024763; ++ *((int *)&__m256_result2) = 0x9d9cb530; ++ *((int *)&__m256_result1) = 0x8001b72e; ++ *((int *)&__m256_result0) = 0xaf12d5f0; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x1f0fdf7f; ++ *((int *)&__m256_op06) = 0x3e3b31d4; ++ *((int *)&__m256_op05) = 0x7ff80000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x1f0fdf7f; ++ *((int *)&__m256_op02) = 0x3e3b31d4; ++ *((int *)&__m256_op01) = 0x7ff80000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x7ff80000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x7ff80000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x80000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x80000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x80000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x80000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x0000ffff; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x0000ffff; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000001; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000001; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000001; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000001; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000001; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000001; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000001; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000001; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000200; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000200; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000200; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000200; ++ *((int *)&__m256_op27) = 0xffffffa0; ++ *((int *)&__m256_op26) = 0x00000001; ++ *((int *)&__m256_op25) = 0xffffffe0; ++ *((int *)&__m256_op24) = 0x00000001; ++ *((int *)&__m256_op23) = 0xffffffa0; ++ *((int *)&__m256_op22) = 0x00000001; ++ *((int *)&__m256_op21) = 0xffffffe0; ++ *((int *)&__m256_op20) = 0x00000001; ++ *((int *)&__m256_result7) = 0xffffffa0; ++ *((int *)&__m256_result6) = 0x80000001; ++ *((int *)&__m256_result5) = 0xffffffe0; ++ *((int *)&__m256_result4) = 0x80000001; ++ *((int *)&__m256_result3) = 0xffffffa0; ++ *((int *)&__m256_result2) = 0x80000001; ++ *((int *)&__m256_result1) = 0xffffffe0; ++ *((int *)&__m256_result0) = 0x80000001; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x49810081; ++ *((int *)&__m256_op16) = 0x4843ffe1; ++ *((int *)&__m256_op15) = 0x49810081; ++ *((int *)&__m256_op14) = 0x68410001; ++ *((int *)&__m256_op13) = 0x49810081; ++ *((int *)&__m256_op12) = 0x4843ffe1; ++ *((int *)&__m256_op11) = 0x49810081; ++ *((int *)&__m256_op10) = 0x68410001; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00009fff; ++ *((int *)&__m256_op06) = 0x00002001; ++ *((int *)&__m256_op05) = 0x0000ffff; ++ *((int *)&__m256_op04) = 0x0000ffff; ++ *((int *)&__m256_op03) = 0x00009fff; ++ *((int *)&__m256_op02) = 0x00002001; ++ *((int *)&__m256_op01) = 0x0000ffff; ++ *((int *)&__m256_op00) = 0x0000ffff; ++ *((int *)&__m256_op17) = 0xfffeb683; ++ *((int *)&__m256_op16) = 0x9ffffd80; ++ *((int *)&__m256_op15) = 0xfffe97c0; ++ *((int *)&__m256_op14) = 0x20010001; ++ *((int *)&__m256_op13) = 0xfffeb683; ++ *((int *)&__m256_op12) = 0x9ffffd80; ++ *((int *)&__m256_op11) = 0xfffe97c0; ++ *((int *)&__m256_op10) = 0x20010001; ++ *((int *)&__m256_op27) = 0x00009fff; ++ *((int *)&__m256_op26) = 0x00002001; ++ *((int *)&__m256_op25) = 0x0000ffff; ++ *((int *)&__m256_op24) = 0x0000ffff; ++ *((int *)&__m256_op23) = 0x00009fff; ++ *((int *)&__m256_op22) = 0x00002001; ++ *((int *)&__m256_op21) = 0x0000ffff; ++ *((int *)&__m256_op20) = 0x0000ffff; ++ *((int *)&__m256_result7) = 0xfffeb683; ++ *((int *)&__m256_result6) = 0x80002001; ++ *((int *)&__m256_result5) = 0xfffe97c0; ++ *((int *)&__m256_result4) = 0x8000ffff; ++ *((int *)&__m256_result3) = 0xfffeb683; ++ *((int *)&__m256_result2) = 0x80002001; ++ *((int *)&__m256_result1) = 0xfffe97c0; ++ *((int *)&__m256_result0) = 0x8000ffff; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x7fffffff; ++ *((int *)&__m256_op06) = 0x80000000; ++ *((int *)&__m256_op05) = 0x7fffffff; ++ *((int *)&__m256_op04) = 0x80000000; ++ *((int *)&__m256_op03) = 0x7fffffff; ++ *((int *)&__m256_op02) = 0x80000000; ++ *((int *)&__m256_op01) = 0x7fffffff; ++ *((int *)&__m256_op00) = 0x80000000; ++ *((int *)&__m256_op17) = 0xfd02fd02; ++ *((int *)&__m256_op16) = 0xfd02fd02; ++ *((int *)&__m256_op15) = 0xfd02fd02; ++ *((int *)&__m256_op14) = 0xfd02fd02; ++ *((int *)&__m256_op13) = 0xfd02fd02; ++ *((int *)&__m256_op12) = 0xfd02fd02; ++ *((int *)&__m256_op11) = 0xfd02fd02; ++ *((int *)&__m256_op10) = 0xfd02fd02; ++ *((int *)&__m256_op27) = 0xfd02fd02; ++ *((int *)&__m256_op26) = 0xfd02fd02; ++ *((int *)&__m256_op25) = 0xfd02fd02; ++ *((int *)&__m256_op24) = 0xfd02fd02; ++ *((int *)&__m256_op23) = 0xfd02fd02; ++ *((int *)&__m256_op22) = 0xfd02fd02; ++ *((int *)&__m256_op21) = 0xfd02fd02; ++ *((int *)&__m256_op20) = 0xfd02fd02; ++ *((int *)&__m256_result7) = 0x7fffffff; ++ *((int *)&__m256_result6) = 0x7d02fd02; ++ *((int *)&__m256_result5) = 0x7fffffff; ++ *((int *)&__m256_result4) = 0x7d02fd02; ++ *((int *)&__m256_result3) = 0x7fffffff; ++ *((int *)&__m256_result2) = 0x7d02fd02; ++ *((int *)&__m256_result1) = 0x7fffffff; ++ *((int *)&__m256_result0) = 0x7d02fd02; ++ __m256_out = __lasx_xvfnmadd_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xffffffff; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xbf7f7fff; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xffffffff; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xe651bfff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0xffffffff; ++ *((int *)&__m256_op22) = 0xf328dfff; ++ *((int *)&__m256_op21) = 0x6651bfff; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0x00000000; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0x00000000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x07070707; ++ *((int *)&__m256_op05) = 0x01020400; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00020100; ++ *((int *)&__m256_op01) = 0x07030200; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0xffffff80; ++ *((int *)&__m256_op16) = 0xfefeff00; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x01000400; ++ *((int *)&__m256_op13) = 0xffffff80; ++ *((int *)&__m256_op12) = 0xfeff0000; ++ *((int *)&__m256_op11) = 0x02020080; ++ *((int *)&__m256_op10) = 0x5c800400; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0xffffffff; ++ *((int *)&__m256_op22) = 0xf328dfff; ++ *((int *)&__m256_op21) = 0x6651bfff; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffff80; ++ *((int *)&__m256_result6) = 0x46867f79; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xf328dfff; ++ *((int *)&__m256_result1) = 0x6651bfff; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0xffffffff; ++ *((int *)&__m256_op06) = 0xe0000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xe0000000; ++ *((int *)&__m256_op03) = 0xffffffff; ++ *((int *)&__m256_op02) = 0xe0000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xe0000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x80000000; ++ *((int *)&__m256_op14) = 0x80000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x80000000; ++ *((int *)&__m256_op10) = 0x80000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0x00000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0x00000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x7f800000; ++ *((int *)&__m256_op26) = 0x7f800000; ++ *((int *)&__m256_op25) = 0x7fc00000; ++ *((int *)&__m256_op24) = 0x7fc00000; ++ *((int *)&__m256_op23) = 0x7f800000; ++ *((int *)&__m256_op22) = 0x7f800000; ++ *((int *)&__m256_op21) = 0x7fc00000; ++ *((int *)&__m256_op20) = 0x7fc00000; ++ *((int *)&__m256_result7) = 0x7f800000; ++ *((int *)&__m256_result6) = 0x7f800000; ++ *((int *)&__m256_result5) = 0x7fc00000; ++ *((int *)&__m256_result4) = 0x7fc00000; ++ *((int *)&__m256_result3) = 0x7f800000; ++ *((int *)&__m256_result2) = 0x7f800000; ++ *((int *)&__m256_result1) = 0x7fc00000; ++ *((int *)&__m256_result0) = 0x7fc00000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x7fefffff; ++ *((int *)&__m256_op16) = 0xffffffff; ++ *((int *)&__m256_op15) = 0x7fefffff; ++ *((int *)&__m256_op14) = 0xffffffff; ++ *((int *)&__m256_op13) = 0x7fefffff; ++ *((int *)&__m256_op12) = 0xffffffff; ++ *((int *)&__m256_op11) = 0x7fefffff; ++ *((int *)&__m256_op10) = 0xffffffff; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x7fefffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0x7fefffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x7fefffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0x7fefffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0xf7f8f7f8; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00003f78; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0xf7f8f7f8; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00003f78; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0xf7f8f7f8; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00003f78; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0xf7f8f7f8; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00003f78; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0xff800000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x80000000; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0xff800000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x80000000; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0xffffffff; ++ *((int *)&__m256_op04) = 0xffffffff; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0xffffffff; ++ *((int *)&__m256_op00) = 0xffffffff; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0xffffffff; ++ *((int *)&__m256_op24) = 0xffffffff; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0xffffffff; ++ *((int *)&__m256_op20) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x01010100; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000405; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x01010100; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000405; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x01010100; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000405; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x01010100; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000405; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x01010100; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0x00000405; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x01010100; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0x00000405; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00800080; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000202; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00800080; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000202; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0xff88ff88; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0xff88ff88; ++ *((int *)&__m256_op27) = 0x00000000; ++ *((int *)&__m256_op26) = 0x00000000; ++ *((int *)&__m256_op25) = 0x00000000; ++ *((int *)&__m256_op24) = 0x00000000; ++ *((int *)&__m256_op23) = 0x00000000; ++ *((int *)&__m256_op22) = 0x00000000; ++ *((int *)&__m256_op21) = 0x00000000; ++ *((int *)&__m256_op20) = 0x00000000; ++ *((int *)&__m256_result7) = 0x80000000; ++ *((int *)&__m256_result6) = 0x80000000; ++ *((int *)&__m256_result5) = 0x80000000; ++ *((int *)&__m256_result4) = 0xffc8ff88; ++ *((int *)&__m256_result3) = 0x80000000; ++ *((int *)&__m256_result2) = 0x80000000; ++ *((int *)&__m256_result1) = 0x80000000; ++ *((int *)&__m256_result0) = 0xffc8ff88; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x00000000; ++ *((int *)&__m256_op14) = 0x00000000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x00000000; ++ *((int *)&__m256_op10) = 0x00000000; ++ *((int *)&__m256_op27) = 0x001fffff; ++ *((int *)&__m256_op26) = 0xffffffff; ++ *((int *)&__m256_op25) = 0xffffffff; ++ *((int *)&__m256_op24) = 0xffffffff; ++ *((int *)&__m256_op23) = 0x001fffff; ++ *((int *)&__m256_op22) = 0xffffffff; ++ *((int *)&__m256_op21) = 0xffffffff; ++ *((int *)&__m256_op20) = 0xffffffff; ++ *((int *)&__m256_result7) = 0x001fffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffffff; ++ *((int *)&__m256_result3) = 0x001fffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffffff; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ *((int *)&__m256_op07) = 0x00000000; ++ *((int *)&__m256_op06) = 0x00000000; ++ *((int *)&__m256_op05) = 0x00000000; ++ *((int *)&__m256_op04) = 0x00000000; ++ *((int *)&__m256_op03) = 0x00000000; ++ *((int *)&__m256_op02) = 0x00000000; ++ *((int *)&__m256_op01) = 0x00000000; ++ *((int *)&__m256_op00) = 0x00000000; ++ *((int *)&__m256_op17) = 0x00000000; ++ *((int *)&__m256_op16) = 0x00000000; ++ *((int *)&__m256_op15) = 0x7fff8000; ++ *((int *)&__m256_op14) = 0x7fff0000; ++ *((int *)&__m256_op13) = 0x00000000; ++ *((int *)&__m256_op12) = 0x00000000; ++ *((int *)&__m256_op11) = 0x7fff8000; ++ *((int *)&__m256_op10) = 0x7fff0000; ++ *((int *)&__m256_op27) = 0xffffffff; ++ *((int *)&__m256_op26) = 0xffffffff; ++ *((int *)&__m256_op25) = 0xffffffff; ++ *((int *)&__m256_op24) = 0xffffff10; ++ *((int *)&__m256_op23) = 0xffffffff; ++ *((int *)&__m256_op22) = 0xffffffff; ++ *((int *)&__m256_op21) = 0xffffffff; ++ *((int *)&__m256_op20) = 0xffffff10; ++ *((int *)&__m256_result7) = 0xffffffff; ++ *((int *)&__m256_result6) = 0xffffffff; ++ *((int *)&__m256_result5) = 0xffffffff; ++ *((int *)&__m256_result4) = 0xffffff10; ++ *((int *)&__m256_result3) = 0xffffffff; ++ *((int *)&__m256_result2) = 0xffffffff; ++ *((int *)&__m256_result1) = 0xffffffff; ++ *((int *)&__m256_result0) = 0xffffff10; ++ __m256_out = __lasx_xvfnmsub_s (__m256_op0, __m256_op1, __m256_op2); ++ ASSERTEQ_32 (__LINE__, __m256_result, __m256_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstp.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstp.c +new file mode 100644 +index 000000000..557f9f8b5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstp.c +@@ -0,0 +1,381 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000080000; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00007f7f00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00007f7f00007fff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000007f00340040; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000007f000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020200008; ++ *((unsigned long *)&__m256i_result1) = 0x0008010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000008; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x03f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op12) = 0x03f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op11) = 0x03f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op10) = 0x03f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op23) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op22) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op21) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op20) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000010; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffff10; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result3) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result1) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xbfbfbfbfbfbfbfbf; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000010; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op12) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op11) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op10) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op21) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000010; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffff10; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x007f007bfffffffb; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x007f007bfffffffb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000010000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000010000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffb8579f; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffb8579f; ++ *((unsigned long *)&__m256i_op23) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op22) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op21) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op20) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000c040c0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000c040c0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op22) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op21) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op20) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffe000ffffffff08; ++ *((unsigned long *)&__m256i_result1) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffe000ffffffff08; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff0000; ++ __m256i_out = __lasx_xvfrstp_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op12) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op11) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op10) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op23) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_op22) = 0x00007fff00000000; ++ *((unsigned long *)&__m256i_op21) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_op20) = 0x00007fff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffff10; ++ __m256i_out = __lasx_xvfrstp_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstpi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstpi.c +new file mode 100644 +index 000000000..cdb7b11aa +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvfrstpi.c +@@ -0,0 +1,350 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x38a966b31be83ee9; ++ *((unsigned long *)&__m256i_op02) = 0x5f6108dc25b8e028; ++ *((unsigned long *)&__m256i_op01) = 0xf41a56e8a20878d7; ++ *((unsigned long *)&__m256i_op00) = 0x683b8b67e20c8ee5; ++ *((unsigned long *)&__m256i_op13) = 0xffffcd42ffffecc0; ++ *((unsigned long *)&__m256i_op12) = 0x00000475ffff4c51; ++ *((unsigned long *)&__m256i_op11) = 0x0000740dffffad17; ++ *((unsigned long *)&__m256i_op10) = 0x00003f4bffff7130; ++ *((unsigned long *)&__m256i_result3) = 0x38a966b31be83ee9; ++ *((unsigned long *)&__m256i_result2) = 0x5f6108dc25b80001; ++ *((unsigned long *)&__m256i_result1) = 0xf41a56e8a20878d7; ++ *((unsigned long *)&__m256i_result0) = 0x683b8b67e20c0001; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1000000000000000; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff0008; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff0008; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff0008ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffff0008ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op02) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op01) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op00) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op13) = 0x00ffffff1e9e9e9e; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff9e9eb09e; ++ *((unsigned long *)&__m256i_op11) = 0x00ffffff1e9e9e9e; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff9e9eb09e; ++ *((unsigned long *)&__m256i_result3) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_result2) = 0xffc00000ffc0ffc0; ++ *((unsigned long *)&__m256i_result1) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_result0) = 0xffc00000ffc0ffc0; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_op02) = 0x0000165e0000480d; ++ *((unsigned long *)&__m256i_op01) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_op00) = 0x0000165e0000480d; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_result3) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_result2) = 0x000016000000480d; ++ *((unsigned long *)&__m256i_result1) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_result0) = 0x000016000000480d; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe800c0d8fffeeece; ++ *((unsigned long *)&__m256i_op02) = 0xffff383efffedf0c; ++ *((unsigned long *)&__m256i_op01) = 0xe800c0d8fffeeece; ++ *((unsigned long *)&__m256i_op00) = 0xffff383efffedf0c; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xe800c000fffeeece; ++ *((unsigned long *)&__m256i_result2) = 0xffff383efffedf0c; ++ *((unsigned long *)&__m256i_result1) = 0xe800c000fffeeece; ++ *((unsigned long *)&__m256i_result0) = 0xffff383efffedf0c; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op12) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op10) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_result3) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff000200000000; ++ *((unsigned long *)&__m256i_result1) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff000200000000; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffff00ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffff00ffffffff; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7c007c0080008000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7c007c0080008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7c00000880008000; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op02) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op01) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op00) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000f000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0008b03e457db03e; ++ *((unsigned long *)&__m256i_result2) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_result1) = 0x0008b03e457db03e; ++ *((unsigned long *)&__m256i_result0) = 0x457db03e45a87310; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_op13) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op12) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result3) = 0x000000000008000b; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_result1) = 0x000000000008000b; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000b; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000dfffffff1; ++ *((unsigned long *)&__m256i_op12) = 0x0000000cfffffff3; ++ *((unsigned long *)&__m256i_op11) = 0x0000000dfffffff1; ++ *((unsigned long *)&__m256i_op10) = 0x0000000cfffffff3; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000001000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000001000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0008000000000000; ++ __m256i_out = __lasx_xvfrstpi_h (__m256i_op0, __m256i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op13) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result3) = 0xff01fffe00000001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result1) = 0xff01fffe00000001; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000001; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op02) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op01) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op00) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_result2) = 0x10ffffff10000006; ++ *((unsigned long *)&__m256i_result1) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_result0) = 0x10ffffff10000006; ++ __m256i_out = __lasx_xvfrstpi_b (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-1.c +new file mode 100644 +index 000000000..fa4d5fd6f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-1.c +@@ -0,0 +1,620 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000fffefe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000fffefe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffb80000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffb80000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000012; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000f0f0003; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000f1003; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000f0001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000011; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffe000ffffffff08; ++ *((unsigned long *)&__m256i_op01) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffe000ffffffff08; ++ *((unsigned long *)&__m256i_op13) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op12) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op11) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op10) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_result3) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result2) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result1) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result0) = 0x00000001fffffff9; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100002000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffc0; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvhsubw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00b7003600120000; ++ *((unsigned long *)&__m256i_op02) = 0x00b7006200fc0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00b7004100190004; ++ *((unsigned long *)&__m256i_op13) = 0xdb801b6d0962003f; ++ *((unsigned long *)&__m256i_op12) = 0xdb8a3109fe0f0024; ++ *((unsigned long *)&__m256i_op11) = 0x9a7f997fff01ffff; ++ *((unsigned long *)&__m256i_op10) = 0xbe632a4f1c3c5653; ++ *((unsigned long *)&__m256i_result3) = 0xffffe54affffffd3; ++ *((unsigned long *)&__m256i_result2) = 0xffffcfae000000d8; ++ *((unsigned long *)&__m256i_result1) = 0x00006681000000ff; ++ *((unsigned long *)&__m256i_result0) = 0xffffd668ffffa9c6; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xbff00000bff00000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xbff00000bff00000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffbff1ffffbff1; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffbff1ffffbff1; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff1fffffff1; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256i_op02) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256i_op00) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffeeffaf; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffeeffaf; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000051; ++ *((unsigned long *)&__m256i_result2) = 0x0000101000000fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000051; ++ *((unsigned long *)&__m256i_result0) = 0x0000101000000fff; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op02) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op00) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op13) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0xffff8180ffff8181; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0xffff8180ffff8181; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00feff0100feff01; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00feff0100feff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvhsubw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op02) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op01) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op00) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007efeff00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007efeff00; ++ *((unsigned long *)&__m256i_result3) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_result1) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffd017d00; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffffe; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op01) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op13) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op12) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op11) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op10) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffe00; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffe00; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvhsubw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvhsubw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffc0c0ffffbfc0; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffc0c0ffffbfc0; ++ __m256i_out = __lasx_xvhsubw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000010000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000010000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffeffff10000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffeffff10000000; ++ __m256i_out = __lasx_xvhsubw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fff8579f; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0007a861; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0007a861; ++ __m256i_out = __lasx_xvhsubw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-2.c +new file mode 100644 +index 000000000..87c3e25b1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhsubw-2.c +@@ -0,0 +1,545 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff70ff01ff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff70ff01ff80; ++ __m256i_out = __lasx_xvhsubw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op02) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op01) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op00) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_result2) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_result1) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_result0) = 0x00c200c200c200bb; ++ __m256i_out = __lasx_xvhsubw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op13) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvhsubw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000f90; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff70; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff70; ++ __m256i_out = __lasx_xvhsubw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op02) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_op01) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op00) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff00bb; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000ff0057; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ff00bb; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000ff0057; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fffa003e; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffb009c; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fffa003e; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffb009c; ++ __m256i_out = __lasx_xvhsubw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvhsubw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x6300000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x6300000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvhsubw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffc001; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000c000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffc001; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000c000; ++ __m256i_out = __lasx_xvhsubw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9ffffd8020010001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff9fffffff9; ++ *((unsigned long *)&__m256i_op01) = 0x9ffffd8020010001; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff9fffffff9; ++ *((unsigned long *)&__m256i_op13) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256i_op12) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x40f69fe73c26f4ee; ++ *((unsigned long *)&__m256i_op10) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000018ffff2b13; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000018ffff2b13; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvhsubw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00800080ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00800080ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff001f; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007fe268; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff001f; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007fe268; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffe40; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffbfffc; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffff00fffffff0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffff00; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000055; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000055; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffefefeff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffff295329; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff01010101; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00d6acd7; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff01010101; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00d6acd7; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x120e120dedf1edf2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x120e120dedf1edf2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000120e120d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000120e120d; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000001; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000dfffffff1; ++ *((unsigned long *)&__m256i_op12) = 0x0000000cfffffff3; ++ *((unsigned long *)&__m256i_op11) = 0x0000000dfffffff1; ++ *((unsigned long *)&__m256i_op10) = 0x0000000cfffffff3; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000000d; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_op12) = 0xffb7ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_op11) = 0x00010000002fff9e; ++ *((unsigned long *)&__m256i_op10) = 0xffb5ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0048007f002f0028; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x004a007f002f0028; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op12) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_op11) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op10) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x24342434ffff2435; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x24342434ffff2435; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_op02) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_op01) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_op00) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffba8300004fc2; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op02) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff8001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op13) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op12) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op11) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op10) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffebffffffebfff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffebffffffebfff; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff7eddffff7ed3; ++ *((unsigned long *)&__m256i_op02) = 0xffff7edfffff7edf; ++ *((unsigned long *)&__m256i_op01) = 0xffff7eddffff7ed3; ++ *((unsigned long *)&__m256i_op00) = 0xffff7edfffff7edf; ++ *((unsigned long *)&__m256i_op13) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op12) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_op11) = 0x00003fef00003fea; ++ *((unsigned long *)&__m256i_op10) = 0x00003ff000003ff0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff3eedffff3ee3; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff3eedffff3ee3; ++ __m256i_out = __lasx_xvhsubw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvld.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvld.c +new file mode 100644 +index 000000000..c1eda6c6c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvld.c +@@ -0,0 +1,86 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_result2) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_result1) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_result0) = 0x0ad152a5ad72feeb; ++ __m256i_out = __lasx_xvld ((unsigned long *)&__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_result2) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_result1) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_result0) = 0x0ad152a5ad72feeb; ++ __m256i_out = __lasx_xvldx ((unsigned long *)&__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result2) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result1) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result0) = 0xebebebebebebebeb; ++ __m256i_out = __lasx_xvldrepl_b ((unsigned long *)&__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0xfeebfeebfeebfeeb; ++ *((unsigned long *)&__m256i_result2) = 0xfeebfeebfeebfeeb; ++ *((unsigned long *)&__m256i_result1) = 0xfeebfeebfeebfeeb; ++ *((unsigned long *)&__m256i_result0) = 0xfeebfeebfeebfeeb; ++ __m256i_out = __lasx_xvldrepl_h ((unsigned long *)&__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0xad72feebad72feeb; ++ *((unsigned long *)&__m256i_result2) = 0xad72feebad72feeb; ++ *((unsigned long *)&__m256i_result1) = 0xad72feebad72feeb; ++ *((unsigned long *)&__m256i_result0) = 0xad72feebad72feeb; ++ __m256i_out = __lasx_xvldrepl_w ((unsigned long *)&__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result2) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result1) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result0) = 0x0ad152a5ad72feeb; ++ __m256i_out = __lasx_xvldrepl_d ((unsigned long *)&__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsub.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsub.c +new file mode 100644 +index 000000000..8c8d4996b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsub.c +@@ -0,0 +1,647 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x074132a240000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x00007ffe81fdfe03; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op02) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op01) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op00) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op13) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op12) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op11) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op10) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result2) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result1) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result0) = 0x555555ab555555ab; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op02) = 0x0000017f0000017d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op00) = 0x0000017f0000017f; ++ *((unsigned long *)&__m256i_op13) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op12) = 0x0000002e0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op10) = 0x0000002e0000fffe; ++ *((unsigned long *)&__m256i_op23) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op22) = 0x0000002e0000ffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op20) = 0x0000002e0000fffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000f7bc0001f7bd; ++ *((unsigned long *)&__m256i_result2) = 0x0000f93b0000017c; ++ *((unsigned long *)&__m256i_result1) = 0x0000f7bc0001f7bd; ++ *((unsigned long *)&__m256i_result0) = 0x0000f93b0000017b; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op02) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op01) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op00) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op13) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op12) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op11) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op10) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x1410141014101410; ++ *((unsigned long *)&__m256i_result2) = 0x1410141014101410; ++ *((unsigned long *)&__m256i_result1) = 0x1410141014101410; ++ *((unsigned long *)&__m256i_result0) = 0x1410141014101410; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdb801b6d0962003f; ++ *((unsigned long *)&__m256i_op02) = 0xdb8a3109fe0f0024; ++ *((unsigned long *)&__m256i_op01) = 0x0000007fff01ffff; ++ *((unsigned long *)&__m256i_op00) = 0xdb8e209d0cce025a; ++ *((unsigned long *)&__m256i_op13) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op12) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op11) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op10) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xffffcc8000000000; ++ *((unsigned long *)&__m256i_op20) = 0x000000007dfdff4b; ++ *((unsigned long *)&__m256i_result3) = 0xdb801b6d0962003f; ++ *((unsigned long *)&__m256i_result2) = 0xdb8a3109fe0f0024; ++ *((unsigned long *)&__m256i_result1) = 0x9a7f997fff01ffff; ++ *((unsigned long *)&__m256i_result0) = 0xbe632a4f1c3c5653; ++ __m256i_out = __lasx_xvmsub_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op23) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op21) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x01010101010000ff; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000004800000; ++ *((unsigned long *)&__m256i_op02) = 0x0000004500f300fb; ++ *((unsigned long *)&__m256i_op01) = 0x0000000004800000; ++ *((unsigned long *)&__m256i_op00) = 0x0000004500f300fb; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op23) = 0x0000000004800000; ++ *((unsigned long *)&__m256i_op22) = 0x0000004500f300fb; ++ *((unsigned long *)&__m256i_op21) = 0x0000000004800000; ++ *((unsigned long *)&__m256i_op20) = 0x0000004500f300fb; ++ *((unsigned long *)&__m256i_result3) = 0x7b7b7b7b80000000; ++ *((unsigned long *)&__m256i_result2) = 0xcacacb1011040500; ++ *((unsigned long *)&__m256i_result1) = 0x7b7b7b7b80000000; ++ *((unsigned long *)&__m256i_result0) = 0xcacacb1011040500; ++ __m256i_out = __lasx_xvmsub_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffefffffffe; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op12) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op11) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op10) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000001a00; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op02) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op00) = 0xff80000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op12) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op11) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op10) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfe7fffecfe7fffec; ++ *((unsigned long *)&__m256i_result2) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_result1) = 0xfe7fffecfe7fffec; ++ *((unsigned long *)&__m256i_result0) = 0xff80000000000000; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_result1) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0xa020202020206431; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ff00000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op22) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op21) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op20) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fff80fe; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff80fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff80007ffe; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff007fff80fe; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op02) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op01) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op00) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result2) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result1) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_result0) = 0x7f807f007f7f817f; ++ __m256i_out = __lasx_xvmsub_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x00001fff200007ef; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result3) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x4000000000000000; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op22) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_op21) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op20) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_result3) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff457db03f; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000fe200000fe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000fe200000fe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x001ffffe00200000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x001ffffe00200000; ++ *((unsigned long *)&__m256i_result3) = 0x0000fe200000fe1f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fe200000fe1f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op12) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op11) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op10) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000009e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000009e; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffff0078ffff0078; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffff0078ffff0078; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_op12) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_op10) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff8; ++ __m256i_out = __lasx_xvmsub_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d6d6d; ++ __m256i_out = __lasx_xvmsub_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotr.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotr.c +new file mode 100644 +index 000000000..21446e55e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotr.c +@@ -0,0 +1,530 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff0001ff02; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff020afefc; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000003fefd; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffefffefff7fff7; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7ffffffbfffb; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff0001ff02; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff020afefc; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000003fefd; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0209fefb08140000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff0001ff04; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff02a0fefc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000cfefd; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op13) = 0xff01ff010000fff9; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ff19; ++ *((unsigned long *)&__m256i_op11) = 0xff02ff020001fffa; ++ *((unsigned long *)&__m256i_op10) = 0x000100010001fffa; ++ *((unsigned long *)&__m256i_result3) = 0x807f807f00000380; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007380; ++ *((unsigned long *)&__m256i_result1) = 0xc03fc03f000001c0; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000001c0; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffe40; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffffe40; ++ __m256i_out = __lasx_xvrotr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op12) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op11) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op10) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvrotr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op13) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000fedd; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000fedd; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000fedd; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000fedd; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x805f0000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x805f0000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x805f0000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x805f0000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result2) = 0x80be0000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result0) = 0x80be0000ffffffff; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result3) = 0x00000000457d607d; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff457d607f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000457d607d; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff457d607f; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x07ffffff07ffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x07ffffff07ffffff; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x07ffffff07ffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x07ffffff07ffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result2) = 0x0ffffffe0ffffffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result0) = 0x0ffffffe0ffffffe; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op02) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_op01) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op00) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_result2) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_result1) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_result0) = 0x001fc0200060047a; ++ __m256i_out = __lasx_xvrotr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ca0000fff80000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00ca0000fff80000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x381800007af80000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x381800007af80000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000086fe0000403e; ++ *((unsigned long *)&__m256i_op02) = 0x0000403e00004040; ++ *((unsigned long *)&__m256i_op01) = 0x000086fe0000403e; ++ *((unsigned long *)&__m256i_op00) = 0x0000403e00004040; ++ *((unsigned long *)&__m256i_op13) = 0x000086fe0000403e; ++ *((unsigned long *)&__m256i_op12) = 0x0000403e00004040; ++ *((unsigned long *)&__m256i_op11) = 0x000086fe0000403e; ++ *((unsigned long *)&__m256i_op10) = 0x0000403e00004040; ++ *((unsigned long *)&__m256i_result3) = 0x00001bfa000000f9; ++ *((unsigned long *)&__m256i_result2) = 0x000000f900004040; ++ *((unsigned long *)&__m256i_result1) = 0x00001bfa000000f9; ++ *((unsigned long *)&__m256i_result0) = 0x000000f900004040; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op02) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op01) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op00) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op13) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op12) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_op11) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op10) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_result3) = 0xffff0607ffff0383; ++ *((unsigned long *)&__m256i_result2) = 0xffff0607ffffc0c1; ++ *((unsigned long *)&__m256i_result1) = 0xffff0607ffff0383; ++ *((unsigned long *)&__m256i_result0) = 0xffff0607ffffc0c1; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op13) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvrotr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007f433c79; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007f433c79; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007f8000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007f8000; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001fff000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffdfff80; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffdfff80; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000010000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotri.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotri.c +new file mode 100644 +index 000000000..c1b8e1752 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvrotri.c +@@ -0,0 +1,394 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbea2e127c046721f; ++ *((unsigned long *)&__m256i_op02) = 0x1729c073816edebe; ++ *((unsigned long *)&__m256i_op01) = 0xde91f010000006f9; ++ *((unsigned long *)&__m256i_op00) = 0x5ef1f90efefaf30d; ++ *((unsigned long *)&__m256i_result3) = 0x515f93f023600fb9; ++ *((unsigned long *)&__m256i_result2) = 0x948b39e0b7405f6f; ++ *((unsigned long *)&__m256i_result1) = 0x48ef087800007c83; ++ *((unsigned long *)&__m256i_result0) = 0x78af877c7d7f86f9; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_op02) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_op01) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op00) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op02) = 0x7f7f7f7f7fff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x7f007f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op00) = 0x7f7f7f7f7fff00ff; ++ *((unsigned long *)&__m256i_result3) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result2) = 0xbfbfbfbfbfff807f; ++ *((unsigned long *)&__m256i_result1) = 0xbf803fbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result0) = 0xbfbfbfbfbfff807f; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000010; ++ __m256i_out = __lasx_xvrotri_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000002a54290; ++ __m256i_out = __lasx_xvrotri_w (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_w (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000007f0000007f; ++ *((unsigned long *)&__m256i_op02) = 0x0000007f0000007f; ++ *((unsigned long *)&__m256i_op01) = 0xff01ff80ff01ff80; ++ *((unsigned long *)&__m256i_op00) = 0xff01ff800000007e; ++ *((unsigned long *)&__m256i_result3) = 0x003f8000003f8000; ++ *((unsigned long *)&__m256i_result2) = 0x003f8000003f8000; ++ *((unsigned long *)&__m256i_result1) = 0xffc07f80ffc07f80; ++ *((unsigned long *)&__m256i_result0) = 0xffc07f80003f0000; ++ __m256i_out = __lasx_xvrotri_w (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x24); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffff6f20; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff6f20; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op02) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op01) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op00) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result3) = 0x4343434343434343; ++ *((unsigned long *)&__m256i_result2) = 0x4343434343434343; ++ *((unsigned long *)&__m256i_result1) = 0x4343434343434343; ++ *((unsigned long *)&__m256i_result0) = 0x4343434343434343; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x38); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffdffd; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffdffd; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffdffd; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffdffd; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvrotri_w (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x35); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_w (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_result2) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_result1) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_result0) = 0x0000f0000000f000; ++ __m256i_out = __lasx_xvrotri_w (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x000007fc00000400; ++ *((unsigned long *)&__m256i_result2) = 0x0000040000000400; ++ *((unsigned long *)&__m256i_result1) = 0x000007fc00000400; ++ *((unsigned long *)&__m256i_result0) = 0x0000040000000400; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x35); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000008000; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvrotri_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_w (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f0000007f0060; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00f7000000f70006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00f7000000f70006; ++ __m256i_out = __lasx_xvrotri_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_d (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_op01) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffbfffffffb; ++ __m256i_out = __lasx_xvrotri_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvst.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvst.c +new file mode 100644 +index 000000000..3c5e775ff +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvst.c +@@ -0,0 +1,102 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x0; ++ *((unsigned long *)&__m256i_result2) = 0x0; ++ *((unsigned long *)&__m256i_result1) = 0x0; ++ *((unsigned long *)&__m256i_result0) = 0x0; ++ __lasx_xvst (__m256i_op0, (unsigned long *)&__m256i_result, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_op0, __m256i_result); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x0; ++ *((unsigned long *)&__m256i_result2) = 0x0; ++ *((unsigned long *)&__m256i_result1) = 0x0; ++ *((unsigned long *)&__m256i_result0) = 0x0; ++ __lasx_xvstx (__m256i_op0, (unsigned long *)&__m256i_result, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_op0, __m256i_result); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x0; ++ *((unsigned long *)&__m256i_result2) = 0x0; ++ *((unsigned long *)&__m256i_result1) = 0x0; ++ *((unsigned long *)&__m256i_result0) = 0x8d; ++ *((unsigned long *)&__m256i_out3) = 0x0; ++ *((unsigned long *)&__m256i_out2) = 0x0; ++ *((unsigned long *)&__m256i_out1) = 0x0; ++ *((unsigned long *)&__m256i_out0) = 0x0; ++ __lasx_xvstelm_b (__m256i_op0, (unsigned long *)&__m256i_out, 0x0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x0; ++ *((unsigned long *)&__m256i_result2) = 0x0; ++ *((unsigned long *)&__m256i_result1) = 0x0; ++ *((unsigned long *)&__m256i_result0) = 0x9100; ++ *((unsigned long *)&__m256i_out3) = 0x0; ++ *((unsigned long *)&__m256i_out2) = 0x0; ++ *((unsigned long *)&__m256i_out1) = 0x0; ++ *((unsigned long *)&__m256i_out0) = 0x0; ++ __lasx_xvstelm_h (__m256i_op0, (unsigned long *)&__m256i_out, 0x0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x0; ++ *((unsigned long *)&__m256i_result2) = 0x0; ++ *((unsigned long *)&__m256i_result1) = 0x0; ++ *((unsigned long *)&__m256i_result0) = 0xe9179100; ++ *((unsigned long *)&__m256i_out3) = 0x0; ++ *((unsigned long *)&__m256i_out2) = 0x0; ++ *((unsigned long *)&__m256i_out1) = 0x0; ++ *((unsigned long *)&__m256i_out0) = 0x0; ++ __lasx_xvstelm_w (__m256i_op0, (unsigned long *)&__m256i_out, 0x0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_result3) = 0x0; ++ *((unsigned long *)&__m256i_result2) = 0x0; ++ *((unsigned long *)&__m256i_result1) = 0x0; ++ *((unsigned long *)&__m256i_result0) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_out3) = 0x0; ++ *((unsigned long *)&__m256i_out2) = 0x0; ++ *((unsigned long *)&__m256i_out1) = 0x0; ++ *((unsigned long *)&__m256i_out0) = 0x0; ++ __lasx_xvstelm_d (__m256i_op0, (unsigned long *)&__m256i_out, 0x0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvhadd-xvhaddw-xv.patch
Added
@@ -0,0 +1,6930 @@ +From 03f7a61fa5efb197cdd66014552aa8727677b891 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:19:28 +0800 +Subject: PATCH 100/124 LoongArch: Add tests for ASX vector + xvhadd/xvhaddw/xvmaddwev/xvmaddwod instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvhaddw-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvhaddw-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmadd.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-3.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-3.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvhaddw-1.c | 560 +++++++++++ + .../loongarch/vector/lasx/lasx-xvhaddw-2.c | 650 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvmadd.c | 742 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaddwev-1.c | 856 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaddwev-2.c | 723 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaddwev-3.c | 940 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaddwod-1.c | 742 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaddwod-2.c | 799 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaddwod-3.c | 820 +++++++++++++++ + 9 files changed, 6832 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmadd.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-3.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-1.c +new file mode 100644 +index 000000000..1cf0ec698 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-1.c +@@ -0,0 +1,560 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7ffffffffffff1f; ++ *((unsigned long *)&__m256i_op02) = 0xbffffffffffffeff; ++ *((unsigned long *)&__m256i_op01) = 0xf7ffffffffffff1f; ++ *((unsigned long *)&__m256i_op00) = 0xbffffffffffffeff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result3) = 0xfff6fffefffe005b; ++ *((unsigned long *)&__m256i_result2) = 0xffbefffefffe005a; ++ *((unsigned long *)&__m256i_result1) = 0xfff6fffefffe005b; ++ *((unsigned long *)&__m256i_result0) = 0xffbefffefffe005a; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0101000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0101000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000000000000; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000060000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000060000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000060000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000060000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000fffffffefffe; ++ *((unsigned long *)&__m256i_result1) = 0xff7fffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000fffffffefffe; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000023; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000023; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op02) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op01) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op00) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op13) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op12) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op11) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op10) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result3) = 0xfff8fffffff8ffff; ++ *((unsigned long *)&__m256i_result2) = 0xfff8fffffff8ffff; ++ *((unsigned long *)&__m256i_result1) = 0xfff8fffffff8ffff; ++ *((unsigned long *)&__m256i_result0) = 0xfff8fffffff8ffff; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op02) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op01) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op00) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op13) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op12) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op11) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op10) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_result3) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result2) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result1) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result0) = 0xffffffecffffffec; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffefffffffe; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffc000400780087; ++ *((unsigned long *)&__m256i_op02) = 0x0000fe80fffc0183; ++ *((unsigned long *)&__m256i_op01) = 0xfffc000400f8ff87; ++ *((unsigned long *)&__m256i_op00) = 0xff80ff00ff7c0183; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff900000800; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffc00000078; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffffc; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffc000000f8; ++ *((unsigned long *)&__m256i_result0) = 0xffffff790000077c; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007ff000000000; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff1fffffff1; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000001ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000000001ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000f6ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000f6ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op02) = 0x0000017f0000017d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op00) = 0x0000017f0000017f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000017f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000017f; ++ __m256i_out = __lasx_xvhaddw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000017000000080; ++ *((unsigned long *)&__m256i_op02) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op01) = 0x0000017000000080; ++ *((unsigned long *)&__m256i_op00) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000017000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000017000000080; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff000000000000; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7ff0000000000000; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffefef800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffefef800; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000400010004; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000400010004; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000400010004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000400010004; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffffffffffff; ++ __m256i_out = __lasx_xvhaddw_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-2.c +new file mode 100644 +index 000000000..14ec081a4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvhaddw-2.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000015d050192cb; ++ *((unsigned long *)&__m256i_op02) = 0x028e509508b16ee9; ++ *((unsigned long *)&__m256i_op01) = 0x000033ff01020e23; ++ *((unsigned long *)&__m256i_op00) = 0x151196b58fd1114d; ++ *((unsigned long *)&__m256i_op13) = 0x0001ffaa0000040e; ++ *((unsigned long *)&__m256i_op12) = 0x0000716800007bb6; ++ *((unsigned long *)&__m256i_op11) = 0x0001ffe80001fe9c; ++ *((unsigned long *)&__m256i_op10) = 0x0000228200001680; ++ *((unsigned long *)&__m256i_result3) = 0x000100ab000500a0; ++ *((unsigned long *)&__m256i_result2) = 0x000200b800080124; ++ *((unsigned long *)&__m256i_result1) = 0x0001011b000200aa; ++ *((unsigned long *)&__m256i_result0) = 0x00150118008f0091; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000001341c4000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000001000310000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00007f7f00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00007f7f00007fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000007f00340040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000007f000000ff; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x8000000180007f7f; ++ *((unsigned long *)&__m256i_op12) = 0xffffafaf80000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000180007f7f; ++ *((unsigned long *)&__m256i_op10) = 0xffffafaf80000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_result2) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_result0) = 0x01fe01ae00ff00ff; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff0102; ++ *((unsigned long *)&__m256i_result2) = 0x007c000000810081; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff0102; ++ *((unsigned long *)&__m256i_result0) = 0x007c000000810081; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffc0003fffc0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffc0003fffc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x007fc0083fc7c007; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x007fc0083fc7c007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f010700c70106; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007f010700c70106; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000e0010000e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000e0010000e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000ff; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000000010000; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_hu_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000002a5; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000002a5; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0e0e0e0e0e0e0e0e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000e0e0e0e0e0e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff8fff9000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff8fff9000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff8fff9000; ++ *((unsigned long *)&__m256i_result3) = 0x00010e0d00009e0e; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00009000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000e0e; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00009000; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op02) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op01) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op00) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000300000004; ++ *((unsigned long *)&__m256i_result2) = 0x0001000300000004; ++ *((unsigned long *)&__m256i_result1) = 0x0001000300000004; ++ *((unsigned long *)&__m256i_result0) = 0x0001000300000004; ++ __m256i_out = __lasx_xvhaddw_wu_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0501030102141923; ++ *((unsigned long *)&__m256i_op02) = 0xffd5020738b43ddb; ++ *((unsigned long *)&__m256i_op01) = 0x010200023b8e4174; ++ *((unsigned long *)&__m256i_op00) = 0xfff4ff4e11410b40; ++ *((unsigned long *)&__m256i_op13) = 0x000019410000e69a; ++ *((unsigned long *)&__m256i_op12) = 0xf259905a09c23be0; ++ *((unsigned long *)&__m256i_op11) = 0x0000883a00000f20; ++ *((unsigned long *)&__m256i_op10) = 0x6d3c2d3a89167aeb; ++ *((unsigned long *)&__m256i_result3) = 0x000000000501e99b; ++ *((unsigned long *)&__m256i_result2) = 0x0000000109973de7; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001020f22; ++ *((unsigned long *)&__m256i_result0) = 0x00000001890b7a39; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007f000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff0000; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op12) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op11) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op10) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_result3) = 0x00000001fff9fff8; ++ *((unsigned long *)&__m256i_result2) = 0x00000001fff9fff8; ++ *((unsigned long *)&__m256i_result1) = 0x00000001fff9fff8; ++ *((unsigned long *)&__m256i_result0) = 0x00000001fff9fff8; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffff81ffffeb2f; ++ *((unsigned long *)&__m256i_op02) = 0x00003f6ee0570b4e; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000018de; ++ *((unsigned long *)&__m256i_op00) = 0xffffffb4ffcec0f1; ++ *((unsigned long *)&__m256i_op13) = 0xffffff81ffffeb2f; ++ *((unsigned long *)&__m256i_op12) = 0x00003f6ee0570b4e; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000018de; ++ *((unsigned long *)&__m256i_op10) = 0xffffffb4ffcec0f1; ++ *((unsigned long *)&__m256i_result3) = 0x00000001ffffeab0; ++ *((unsigned long *)&__m256i_result2) = 0x00000000e0574abc; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000018de; ++ *((unsigned long *)&__m256i_result0) = 0x00000001ffcec0a5; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffe367cc82f8989a; ++ *((unsigned long *)&__m256i_op12) = 0x4f90000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffc3aaa8d58f43c8; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000082f8989a; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000d58f43c8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op12) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_op10) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000170017; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000170017; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000004411; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000236200005111; ++ *((unsigned long *)&__m256i_op02) = 0x0000175e0000490d; ++ *((unsigned long *)&__m256i_op01) = 0x0000236200005111; ++ *((unsigned long *)&__m256i_op00) = 0x0000175e0000490d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000002362; ++ *((unsigned long *)&__m256i_result2) = 0x000000010000175d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000002362; ++ *((unsigned long *)&__m256i_result0) = 0x000000010000175d; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op11) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x000000010000ff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x000000010000ff00; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op02) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op01) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op00) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100003ffe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100003fcd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100003ffe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100003fcd; ++ __m256i_out = __lasx_xvhaddw_du_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffcfa; ++ *((unsigned long *)&__m256i_op01) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffefefffffefe; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000003f; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op12) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op11) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op10) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x9090909090909090; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000000f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000f; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_op02) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_op01) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_op00) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xf3f3f3f3f3f3f4f3; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xf3f3f3f3f3f3f4f3; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000800080008000; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000001fe; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000001ce; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000001fe; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000001ce; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000001fd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000001fd; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op02) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op01) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op00) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op13) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op12) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op11) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op10) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0xfa15fa15fa15fa14; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0xfa15fa15fa15fa14; ++ __m256i_out = __lasx_xvhaddw_qu_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmadd.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmadd.c +new file mode 100644 +index 000000000..f9634b128 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmadd.c +@@ -0,0 +1,742 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x042f0500cfea969a; ++ *((unsigned long *)&__m256i_op02) = 0x58569d7be9179100; ++ *((unsigned long *)&__m256i_op01) = 0xa98d4f7a77c308ee; ++ *((unsigned long *)&__m256i_op00) = 0x0ad152a5ad72feeb; ++ *((unsigned long *)&__m256i_op13) = 0x34ec5670cd4b5ec0; ++ *((unsigned long *)&__m256i_op12) = 0x4f111e4b8e0d7291; ++ *((unsigned long *)&__m256i_op11) = 0xeaa81f47dc3bdd09; ++ *((unsigned long *)&__m256i_op10) = 0x0e0d5fde5df99830; ++ *((unsigned long *)&__m256i_op23) = 0x80c72fcd40fb3bc0; ++ *((unsigned long *)&__m256i_op22) = 0x84bd087966d4ace0; ++ *((unsigned long *)&__m256i_op21) = 0x26aa68b274dc1322; ++ *((unsigned long *)&__m256i_op20) = 0xe072db2bb9d4cd40; ++ *((unsigned long *)&__m256i_result3) = 0x044819410d87e69a; ++ *((unsigned long *)&__m256i_result2) = 0x21d3905ae3e93be0; ++ *((unsigned long *)&__m256i_result1) = 0x5125883a30da0f20; ++ *((unsigned long *)&__m256i_result0) = 0x6d7b2d3ac2777aeb; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffeff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffeff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffff001f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff001f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_op21) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffff1f; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffeff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffff1f; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffeff; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000fffe00010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000fffe00010001; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_op02) = 0x000607f700000001; ++ *((unsigned long *)&__m256i_op01) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_op00) = 0x000607f700000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op22) = 0x0000002e0000ffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000002e0000002e; ++ *((unsigned long *)&__m256i_op20) = 0x0000002e0000fffe; ++ *((unsigned long *)&__m256i_result3) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_result2) = 0x000607f700000001; ++ *((unsigned long *)&__m256i_result1) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_result0) = 0x000607f700000001; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000003f00000000; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x370036db92c4007e; ++ *((unsigned long *)&__m256i_op02) = 0x371462137c1e0049; ++ *((unsigned long *)&__m256i_op01) = 0x800000fe7e02fffe; ++ *((unsigned long *)&__m256i_op00) = 0x371c413b999d04b5; ++ *((unsigned long *)&__m256i_op13) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_op12) = 0xffb7ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_op11) = 0x00010000002fff9e; ++ *((unsigned long *)&__m256i_op10) = 0xffb5ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_op23) = 0xffff00ff00ffff00; ++ *((unsigned long *)&__m256i_op22) = 0xff000000ff00ff00; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffff00ffff; ++ *((unsigned long *)&__m256i_op20) = 0xff00000000ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x37fe365b920d007e; ++ *((unsigned long *)&__m256i_result2) = 0x381462137d1e0149; ++ *((unsigned long *)&__m256i_result1) = 0x80ff00fe7e020060; ++ *((unsigned long *)&__m256i_result0) = 0x381c413b99cd04dd; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op12) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op11) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op10) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_op23) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op22) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op21) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op20) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_result3) = 0xd100645944100004; ++ *((unsigned long *)&__m256i_result2) = 0xd1908469108400d1; ++ *((unsigned long *)&__m256i_result1) = 0x0000000404040104; ++ *((unsigned long *)&__m256i_result0) = 0xd1108199714910f9; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_op23) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op22) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op20) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x61f1000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0108000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x61f1a18100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0108000000000000; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000055555555; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000004; ++ *((unsigned long *)&__m256i_op11) = 0x0000000055555555; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000004; ++ *((unsigned long *)&__m256i_op23) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2aaaaaaa2aaaaaab; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x2aaaaaaa2aaaaaab; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op02) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op01) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op00) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_result2) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_result1) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_result0) = 0x7c007c007c007c00; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x0000fd00ffff02fe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001fffeff; ++ *((unsigned long *)&__m256i_op10) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op23) = 0x00007f7f00007f00; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x00007f7f00007fff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0100; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffee0000ff4c; ++ *((unsigned long *)&__m256i_op12) = 0x0000ff050000ff3c; ++ *((unsigned long *)&__m256i_op11) = 0x0000fff90000ff78; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffa80000ff31; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0101010127272525; ++ *((unsigned long *)&__m256i_op22) = 0x23a2a121179e951d; ++ *((unsigned long *)&__m256i_op21) = 0x0101010127272525; ++ *((unsigned long *)&__m256i_op20) = 0x23a2a121179e951d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvmadd_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op23) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fefffffffffffff; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op22) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op21) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op20) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x008e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x008e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_op12) = 0x0007ffff0007ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_op10) = 0x0007ffff0007ffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x008e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x008e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007000008e700000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007000008e700000; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op02) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op00) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op22) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op21) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op20) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result3) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_result2) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_result0) = 0x0100000100000001; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmadd_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op22) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op21) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op20) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvmadd_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op13) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000080040; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x00009fff00002001; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x00009fff00002001; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0001497c98ea4fca; ++ *((unsigned long *)&__m256i_op22) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0001497c98ea4fca; ++ *((unsigned long *)&__m256i_op20) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000006715b036; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x000000006715b036; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmadd_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007f80; ++ __m256i_out = __lasx_xvmadd_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d6d6d; ++ __m256i_out = __lasx_xvmadd_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7f80ffffff808000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7f80ffffff808000; ++ *((unsigned long *)&__m256i_op13) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffe0ffe000000000; ++ *((unsigned long *)&__m256i_op11) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffe0ffe000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffe0ffe000000001; ++ *((unsigned long *)&__m256i_result2) = 0x7fa0001fff808000; ++ *((unsigned long *)&__m256i_result1) = 0xffe0ffe000000001; ++ *((unsigned long *)&__m256i_result0) = 0x7fa0001fff808000; ++ __m256i_out = __lasx_xvmadd_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-1.c +new file mode 100644 +index 000000000..6238685bc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-1.c +@@ -0,0 +1,856 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff000100000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff000100000000; ++ __m256i_out = __lasx_xvmaddwev_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op12) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op10) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff8fff8fff8fff8; ++ __m256i_out = __lasx_xvmaddwev_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op23) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000f7f8f7f8; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000003f78; ++ *((unsigned long *)&__m256i_op01) = 0x00000000f7f8f7f8; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000003f78; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op22) = 0x805f0000ffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op20) = 0x805f0000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000f7f8f7f8; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000003f78; ++ *((unsigned long *)&__m256i_result1) = 0x00000000f7f8f7f8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000003f78; ++ __m256i_out = __lasx_xvmaddwev_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op02) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op00) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0002001800ff0078; ++ *((unsigned long *)&__m256i_op12) = 0x01f8007001f80070; ++ *((unsigned long *)&__m256i_op11) = 0x0002001800ff0078; ++ *((unsigned long *)&__m256i_op10) = 0x01f8007001f80070; ++ *((unsigned long *)&__m256i_op23) = 0x0218ff78fc38fc38; ++ *((unsigned long *)&__m256i_op22) = 0xfc00000000000048; ++ *((unsigned long *)&__m256i_op21) = 0x0218ff78fc38fc38; ++ *((unsigned long *)&__m256i_op20) = 0xfc00000000000048; ++ *((unsigned long *)&__m256i_result3) = 0x00300b40fc001678; ++ *((unsigned long *)&__m256i_result2) = 0xfc00000000001f80; ++ *((unsigned long *)&__m256i_result1) = 0x00300b40fc001678; ++ *((unsigned long *)&__m256i_result0) = 0xfc00000000001f80; ++ __m256i_out = __lasx_xvmaddwev_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe8440000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe8440000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffe8440000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffe8440000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffe8440000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffe8440000; ++ __m256i_out = __lasx_xvmaddwev_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_op01) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_op13) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op12) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op11) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op10) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_result1) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffefffefffefffef; ++ __m256i_out = __lasx_xvmaddwev_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op12) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000e0e0e0e0; ++ *((unsigned long *)&__m256i_op10) = 0xe0e0e0e0e0e0e0e0; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xebfd15f000000000; ++ *((unsigned long *)&__m256i_op02) = 0x01700498ff8f1600; ++ *((unsigned long *)&__m256i_op01) = 0xf520c7c024221300; ++ *((unsigned long *)&__m256i_op00) = 0x00802fd0ff540a80; ++ *((unsigned long *)&__m256i_op13) = 0xebfd15f000000000; ++ *((unsigned long *)&__m256i_op12) = 0x01700498ff8f1600; ++ *((unsigned long *)&__m256i_op11) = 0xf520c7c024221300; ++ *((unsigned long *)&__m256i_op10) = 0x00802fd0ff540a80; ++ *((unsigned long *)&__m256i_op23) = 0xf96d674800000000; ++ *((unsigned long *)&__m256i_op22) = 0x44a4330e2c7116c0; ++ *((unsigned long *)&__m256i_op21) = 0x14187a7822b653c0; ++ *((unsigned long *)&__m256i_op20) = 0xfbe0b866962b96d0; ++ *((unsigned long *)&__m256i_result3) = 0xebfd15f000000000; ++ *((unsigned long *)&__m256i_result2) = 0x015c6a7facc39600; ++ *((unsigned long *)&__m256i_result1) = 0xfa070a51cbd95300; ++ *((unsigned long *)&__m256i_result0) = 0x00c7463075439280; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0555550000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0555550000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_result3) = 0x0555550000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0555550000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x807e80fd80fe80fd; ++ *((unsigned long *)&__m256i_op02) = 0x80938013800d8002; ++ *((unsigned long *)&__m256i_op01) = 0x807e80fd80fe0000; ++ *((unsigned long *)&__m256i_op00) = 0x80938013800d0005; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffff00001fff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffff00001fff; ++ *((unsigned long *)&__m256i_result3) = 0x807e80fd80fe80fd; ++ *((unsigned long *)&__m256i_result2) = 0x80938013800d8002; ++ *((unsigned long *)&__m256i_result1) = 0x807e80fd80fe0000; ++ *((unsigned long *)&__m256i_result0) = 0x80938013800d0005; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_op02) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_op01) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_op00) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_op13) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_op12) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_op11) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_op10) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_result2) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_result1) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_result0) = 0x556caad9aabbaa88; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xff7f7f7fff7fffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xff7f7f7fff7fffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3f7f7f7eff800000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3f7f7f7eff800000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffeffffffdd; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x002affaa00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffeffffffdd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffdc; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op11) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op23) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op21) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000001000b000b; ++ *((unsigned long *)&__m256i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000001000b000b; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op02) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op01) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_op00) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op23) = 0x2020080800000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000004044f4f; ++ *((unsigned long *)&__m256i_op21) = 0x0ef11ae55a5a6767; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_result2) = 0x6040190d20227a78; ++ *((unsigned long *)&__m256i_result1) = 0x132feeabd2d33b38; ++ *((unsigned long *)&__m256i_result0) = 0x6040190d00000000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x3); ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000fe0000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000fe0000000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000118; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000118; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_op00) = 0x00007fff7fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff7fff7fff; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_op12) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_op11) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_op10) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1086658a18ba3594; ++ *((unsigned long *)&__m256i_op02) = 0x160fe9f000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1086658a18ba3594; ++ *((unsigned long *)&__m256i_op00) = 0x160fe9f000000000; ++ *((unsigned long *)&__m256i_op13) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_op12) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_op11) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_op10) = 0xe161616161614f61; ++ *((unsigned long *)&__m256i_op23) = 0x0000616100004f61; ++ *((unsigned long *)&__m256i_op22) = 0x0000616100004f61; ++ *((unsigned long *)&__m256i_op21) = 0x0000616100004f61; ++ *((unsigned long *)&__m256i_op20) = 0x0000616100004f61; ++ *((unsigned long *)&__m256i_result3) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_result2) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_result1) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_result0) = 0x4df5b1a3ed5e02c1; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff000100000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x01fffffffe000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x01fffffffe000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x01fffffffe000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x01fffffffe000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfe00000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op22) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op21) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op20) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_op23) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op22) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op21) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op20) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result2) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result0) = 0x817f11ed81800ff0; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xff00000000ffffff; ++ *((unsigned long *)&__m256i_op01) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xff00000000ffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000ffffff; ++ *((unsigned long *)&__m256i_result1) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000ffffff; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op22) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op20) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000101000001010; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff80000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-2.c +new file mode 100644 +index 000000000..5fa080375 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-2.c +@@ -0,0 +1,723 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f7f7f80; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0200000002000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_op01) = 0x0200000002000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff01fb0408; ++ *((unsigned long *)&__m256i_op12) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff01fb0408; ++ *((unsigned long *)&__m256i_op10) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_op23) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_op22) = 0x00003cfc0000006f; ++ *((unsigned long *)&__m256i_op21) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_op20) = 0x00003cfc0000006f; ++ *((unsigned long *)&__m256i_result3) = 0x02007f8002000400; ++ *((unsigned long *)&__m256i_result2) = 0x0000c5dc02005f64; ++ *((unsigned long *)&__m256i_result1) = 0x02007f8002000400; ++ *((unsigned long *)&__m256i_result0) = 0x0000c5dc02005f64; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000700020004; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000700020004; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op23) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op21) = 0x0040000000000003; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x000000070002000a; ++ __m256i_out = __lasx_xvmaddwev_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_op02) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_op01) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_op00) = 0xff874dc687870000; ++ *((unsigned long *)&__m256i_op13) = 0x41dfffc000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x41dfffdfffc00000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0001fbf9fbe29f52; ++ *((unsigned long *)&__m256i_op22) = 0x5b409c0000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0001fbf9fbe29f52; ++ *((unsigned long *)&__m256i_op20) = 0x5b409c0000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfbba01c0003f7e3f; ++ *((unsigned long *)&__m256i_result2) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_result1) = 0xfbd884e7003f7e3f; ++ *((unsigned long *)&__m256i_result0) = 0xff874dc687870000; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op01) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result3) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result2) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_result1) = 0x3fff3fff3fff4000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000403f3fff; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x40effc0000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x40effc0000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00007f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op12) = 0x00010003fc827a86; ++ *((unsigned long *)&__m256i_op11) = 0x00007f7f7f7f0000; ++ *((unsigned long *)&__m256i_op10) = 0x7f017fc0ddbf7d86; ++ *((unsigned long *)&__m256i_op23) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x00153f1594ea02ff; ++ *((unsigned long *)&__m256i_op21) = 0x0000ffffffff0100; ++ *((unsigned long *)&__m256i_op20) = 0xff15c1ea95ea02ff; ++ *((unsigned long *)&__m256i_result3) = 0xc06e7c817f7e8081; ++ *((unsigned long *)&__m256i_result2) = 0x0000bd3f016f177a; ++ *((unsigned long *)&__m256i_result1) = 0xc06e7c8100000000; ++ *((unsigned long *)&__m256i_result0) = 0x60c485800178147a; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000011f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000011f; ++ *((unsigned long *)&__m256i_op23) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op22) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op21) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op20) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000192540; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000192540; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff88ff88; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_op02) = 0xffffdf5b000041b0; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_op00) = 0xffffdf5b000041b0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op22) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_op21) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op20) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_result2) = 0xffffdf5b000041b0; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_result0) = 0xffffdf5b000041b0; ++ __m256i_out = __lasx_xvmaddwev_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000fb8000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000fb8000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x807f807f00000380; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007380; ++ *((unsigned long *)&__m256i_op01) = 0xc03fc03f000001c0; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000001c0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_result3) = 0x807f807f00000380; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007380; ++ *((unsigned long *)&__m256i_result1) = 0xc03fc03f000001c0; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000001c0; ++ __m256i_out = __lasx_xvmaddwev_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xff80ff00ff80ff01; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xff80ff00ff80ff01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x007f00ff007f00fe; ++ *((unsigned long *)&__m256i_op22) = 0xf711ee11f711ee91; ++ *((unsigned long *)&__m256i_op21) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op20) = 0xf711ee11f711ee11; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff80ff00ff80ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff80ff00ff80ff01; ++ __m256i_out = __lasx_xvmaddwev_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op12) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op11) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op10) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op23) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_op22) = 0xffff800300000000; ++ *((unsigned long *)&__m256i_op21) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_op20) = 0xffff800300000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvmaddwev_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op12) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op11) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op10) = 0x01fe01fe00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op01) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op13) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op12) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op11) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op10) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_result3) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_result2) = 0x00000045ff740023; ++ *((unsigned long *)&__m256i_result1) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_result0) = 0x00000045ff740023; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x000000000155b200; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000b70000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000016e00; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000001e001e001e0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000001e001e001e0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-3.c +new file mode 100644 +index 000000000..40549448e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwev-3.c +@@ -0,0 +1,940 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0003ff540000081c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0003ffd00003fd38; ++ *((unsigned long *)&__m256i_op13) = 0x0001ffaa0000040e; ++ *((unsigned long *)&__m256i_op12) = 0x0000716800007bb6; ++ *((unsigned long *)&__m256i_op11) = 0x0001ffe80001fe9c; ++ *((unsigned long *)&__m256i_op10) = 0x0000228200001680; ++ *((unsigned long *)&__m256i_op23) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256i_op22) = 0xc5c085372cfabfba; ++ *((unsigned long *)&__m256i_op21) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256i_op20) = 0x0658f2dc0eb21e3c; ++ *((unsigned long *)&__m256i_result3) = 0x002e4db200000000; ++ *((unsigned long *)&__m256i_result2) = 0x000315ac0000d658; ++ *((unsigned long *)&__m256i_result1) = 0x00735278007cf94c; ++ *((unsigned long *)&__m256i_result0) = 0x0003ed8800031b38; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff01ff01ff01; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff0001ff04; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff02a0fefc; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000cfefd; ++ *((unsigned long *)&__m256i_op13) = 0x6100000800060005; ++ *((unsigned long *)&__m256i_op12) = 0x5ee1c073b800c916; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x5ff00007fff9fff3; ++ *((unsigned long *)&__m256i_op23) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op22) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op21) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op20) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff7fffbfefa; ++ *((unsigned long *)&__m256i_result2) = 0xff1eff1902a0fea4; ++ *((unsigned long *)&__m256i_result1) = 0xff10000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff10fff9ff13fd17; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfafafafafafafafa; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000fefefe; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xf9fbf9fbf9fbf9fb; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result1) = 0xfdfffdfffdfffdff; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff01fffffdff; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op01) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000627; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000627; ++ *((unsigned long *)&__m256i_op23) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result2) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_result1) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result0) = 0x000000003fff3fff; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000400; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000400; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_result2) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_result0) = 0xff00ff00ff00ef32; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_op22) = 0xfffffffffdd97dc4; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_op20) = 0xfffffffffdd97dc4; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256i_result2) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256i_result0) = 0x1010100f10100fd4; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op02) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op01) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op00) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result2) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result1) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_result0) = 0xebebebebebebebeb; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffe0ffe000000000; ++ *((unsigned long *)&__m256i_op11) = 0x001f001fffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffe0ffe000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x34ec5670cd4b5ec0; ++ *((unsigned long *)&__m256i_op02) = 0x4f111e4b8e0d7291; ++ *((unsigned long *)&__m256i_op01) = 0xeaa81f47dc3bdd09; ++ *((unsigned long *)&__m256i_op00) = 0x0e0d5fde5df99830; ++ *((unsigned long *)&__m256i_op13) = 0x67390c19e4b17547; ++ *((unsigned long *)&__m256i_op12) = 0xbacda0f96d2cec01; ++ *((unsigned long *)&__m256i_op11) = 0xee20ad1adae2cc16; ++ *((unsigned long *)&__m256i_op10) = 0x5a2003c6a406fe53; ++ *((unsigned long *)&__m256i_op23) = 0x80c72fcd40fb3bc0; ++ *((unsigned long *)&__m256i_op22) = 0x84bd087966d4ace0; ++ *((unsigned long *)&__m256i_op21) = 0x26aa68b274dc1322; ++ *((unsigned long *)&__m256i_op20) = 0xe072db2bb9d4cd40; ++ *((unsigned long *)&__m256i_result3) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256i_result2) = 0x5464fbfc416b9f71; ++ *((unsigned long *)&__m256i_result1) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256i_result0) = 0x0d8264202b8ea3f0; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff0000ffff00ff; ++ *((unsigned long *)&__m256i_op02) = 0xff000000ffffff00; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffffffff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x01fa022a01a401e5; ++ *((unsigned long *)&__m256i_op12) = 0x030d03aa0079029b; ++ *((unsigned long *)&__m256i_op11) = 0x024c01f901950261; ++ *((unsigned long *)&__m256i_op10) = 0x008102c2008a029f; ++ *((unsigned long *)&__m256i_op23) = 0x002e4db200000000; ++ *((unsigned long *)&__m256i_op22) = 0x000315ac0000d658; ++ *((unsigned long *)&__m256i_op21) = 0x00735278007cf94c; ++ *((unsigned long *)&__m256i_op20) = 0x0003ed8800031b38; ++ *((unsigned long *)&__m256i_result3) = 0x01a72334ffff00ff; ++ *((unsigned long *)&__m256i_result2) = 0xff4f6838ff937648; ++ *((unsigned long *)&__m256i_result1) = 0x00a2afb7fff00ecb; ++ *((unsigned long *)&__m256i_result0) = 0xffce110f004658c7; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_op02) = 0x000000003a099512; ++ *((unsigned long *)&__m256i_op01) = 0x280ac9da313763f5; ++ *((unsigned long *)&__m256i_op00) = 0xe032c738adcc6bbf; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xfffe000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000ffff00010000; ++ *((unsigned long *)&__m256i_op21) = 0x0001000100020001; ++ *((unsigned long *)&__m256i_op20) = 0x0000fffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff0001; ++ *((unsigned long *)&__m256i_result2) = 0x000000003a099512; ++ *((unsigned long *)&__m256i_result1) = 0x280ac9da313763f5; ++ *((unsigned long *)&__m256i_result0) = 0xe032c738adcc6bbf; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op01) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op13) = 0x000000000045f3fb; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000000045f3fb; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result2) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result0) = 0xf7f7f7f7f7f7f7f7; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op01) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_result1) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00010003; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000001f0000001f; ++ *((unsigned long *)&__m256i_op10) = 0x0000001f0000ffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000060008; ++ *((unsigned long *)&__m256i_op22) = 0x00000000000c005b; ++ *((unsigned long *)&__m256i_op21) = 0xfffffffffffe0000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000040053; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff0007fff7; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff005affa4; ++ *((unsigned long *)&__m256i_result1) = 0xffffffe100000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000053ffac; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op22) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op21) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op20) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_op02) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_op00) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_op12) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_op10) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_op23) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_result2) = 0x5fff5fff607f0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000420080000000; ++ *((unsigned long *)&__m256i_result0) = 0x5fff5fff607f0000; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op02) = 0x0100004300000000; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op00) = 0x0100004300000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op22) = 0xff00010001000100; ++ *((unsigned long *)&__m256i_op21) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op20) = 0xff00010001000100; ++ *((unsigned long *)&__m256i_result3) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result2) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_result1) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_result0) = 0x01ffff4300ffff00; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000001000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000001000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op13) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op12) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op11) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op10) = 0xffff0607ffff0607; ++ *((unsigned long *)&__m256i_op23) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op22) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_op21) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op20) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffb8579f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffdbbbcf; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffb8579f; ++ __m256i_out ++ = __lasx_xvmaddwev_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out ++ = __lasx_xvmaddwev_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_op02) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_op01) = 0x00b200b300800080; ++ *((unsigned long *)&__m256i_op00) = 0x00b200b300800080; ++ *((unsigned long *)&__m256i_op13) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_result2) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_result1) = 0x00b200b300800080; ++ *((unsigned long *)&__m256i_result0) = 0x00b200b300800080; ++ __m256i_out ++ = __lasx_xvmaddwev_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000202020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000404040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000202020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000404040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000202020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000404040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000202020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000404040; ++ __m256i_out ++ = __lasx_xvmaddwev_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1fa0000000080000; ++ __m256i_out ++ = __lasx_xvmaddwev_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000001; ++ __m256i_out ++ = __lasx_xvmaddwev_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000eef14fe8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0202020201010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000eef14fe8; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0202020201010000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xfe02fe02fee5fe22; ++ *((unsigned long *)&__m256i_op20) = 0xff49fe4200000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000eef14fe8; ++ *((unsigned long *)&__m256i_result1) = 0xfffe928f1313c9cc; ++ *((unsigned long *)&__m256i_result0) = 0x4244020201010000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op02) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op01) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op00) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result2) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result1) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result0) = 0x0005000500050005; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op23) = 0x3f3f3f3f3f3f3f3f; ++ *((unsigned long *)&__m256i_op22) = 0x3f3f3f3f3f3f3f3f; ++ *((unsigned long *)&__m256i_op21) = 0x000000003f3f3f3f; ++ *((unsigned long *)&__m256i_op20) = 0x3f3f3f3f00000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_result2) = 0xc6c6c6c68787878a; ++ *((unsigned long *)&__m256i_result1) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_result0) = 0x8787878a00000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op23) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op22) = 0xc6c6c6c68787878a; ++ *((unsigned long *)&__m256i_op21) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op20) = 0x8787878a00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffe3; ++ *((unsigned long *)&__m256i_result2) = 0x63636344c3c3c4f6; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffc3; ++ *((unsigned long *)&__m256i_result0) = 0xc3c3c500fffffff6; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op12) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op10) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op12) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_op11) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op10) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffbfffcffeffff0; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffbfffcffeffff0; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000b0cfffff4f3; ++ *((unsigned long *)&__m256i_op02) = 0x000f9bb562f56c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000b0cfffff4f3; ++ *((unsigned long *)&__m256i_op00) = 0x000f9bb562f56c80; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op23) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op22) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op21) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op20) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0018761ed60b5d7f; ++ *((unsigned long *)&__m256i_result2) = 0xabdcdc9938afafe9; ++ *((unsigned long *)&__m256i_result1) = 0x0018761ed60b5d7f; ++ *((unsigned long *)&__m256i_result0) = 0xabdcdc9938afafe9; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-1.c +new file mode 100644 +index 000000000..683876933 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-1.c +@@ -0,0 +1,742 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00ffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op02) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op01) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op00) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_op13) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op23) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op22) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op21) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op20) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_result3) = 0x1031146010201020; ++ *((unsigned long *)&__m256i_result2) = 0x1020102010201020; ++ *((unsigned long *)&__m256i_result1) = 0x1031146010201020; ++ *((unsigned long *)&__m256i_result0) = 0x1020102010201020; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_op22) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_op21) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_op20) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3d3d3d3d3d3d3d3d; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xfff8fffffff8ffff; ++ *((unsigned long *)&__m256i_op22) = 0xfff8fffffff8ffff; ++ *((unsigned long *)&__m256i_op21) = 0xfff8fffffff8ffff; ++ *((unsigned long *)&__m256i_op20) = 0xfff8fffffff8ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x94d7fb5200000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x94d7fb5200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_op22) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_op20) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x94d7fb5200000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x94d7fb5200000000; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op23) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op21) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0x0000020000010201; ++ *((unsigned long *)&__m256i_result2) = 0x0000020000010201; ++ *((unsigned long *)&__m256i_result1) = 0x0000020000010201; ++ *((unsigned long *)&__m256i_result0) = 0x0000020000010201; ++ __m256i_out = __lasx_xvmaddwod_h_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op22) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op21) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op20) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000017e; ++ __m256i_out = __lasx_xvmaddwod_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003f3fc6c68787; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003f3f87870000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op22) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op21) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op20) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m256i_result2) = 0x00003e3ec6c68686; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fffffeff; ++ *((unsigned long *)&__m256i_result0) = 0x00003e3e87870000; ++ __m256i_out = __lasx_xvmaddwod_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_op02) = 0x019d00a2003a0000; ++ *((unsigned long *)&__m256i_op01) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_op00) = 0x019d00a2003a0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000077fff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_result2) = 0x019d00a20039fff9; ++ *((unsigned long *)&__m256i_result1) = 0x01fe007a01c40110; ++ *((unsigned long *)&__m256i_result0) = 0x019d00a2003a0000; ++ __m256i_out = __lasx_xvmaddwod_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000003cc0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000003cc0; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000003cc0; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000003cc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_w_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256i_op02) = 0x0000468600007f79; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000f3280000dfff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_op10) = 0x00007fff7fff7fff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256i_result2) = 0x0000468600007f79; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000f3280000dfff; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffff90ffffff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffff90ffffff80; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_result0) = 0x7ff0000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x3fffffffff7f0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x3fffffffff7f0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000c7aff7c00; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000c7aff7c00; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_op23) = 0x0000000002030000; ++ *((unsigned long *)&__m256i_op22) = 0x030303670101fd90; ++ *((unsigned long *)&__m256i_op21) = 0x0000000002030000; ++ *((unsigned long *)&__m256i_op20) = 0x030303670101fd90; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3ffffffffc7bfc99; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3ffffffffc7bfc99; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op23) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op22) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op21) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op20) = 0xff80000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0200000202000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0200000202000002; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000100080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf800f800f800c000; ++ *((unsigned long *)&__m256i_op02) = 0xf800f800f800a000; ++ *((unsigned long *)&__m256i_op01) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_op00) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_op13) = 0xffff00ffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0001000100010000; ++ *((unsigned long *)&__m256i_op22) = 0x020afefb08140000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op20) = 0x0003fffc00060000; ++ *((unsigned long *)&__m256i_result3) = 0xf800f7fff8ffc0ff; ++ *((unsigned long *)&__m256i_result2) = 0xf8fff7fff7ffa000; ++ *((unsigned long *)&__m256i_result1) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_result0) = 0xf800f800f800e000; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffff39ffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffff39ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_q_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-2.c +new file mode 100644 +index 000000000..f9f88b654 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-2.c +@@ -0,0 +1,799 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000ffff8000ffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff80008000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800080008000b8f1; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x074132a240000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000ffff8000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x06f880008000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x800080008000b8f1; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000c0; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000c0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000c0; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000000c0; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x00000012481e4950; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000001658166830; ++ *((unsigned long *)&__m256i_result3) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result2) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result0) = 0x0000004000000040; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op01) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result2) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result0) = 0xf7f7f7f7f7f7f7f7; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op12) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1f60010000080100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1f60010000080100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x1fa0000000080000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1f60010000080100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1f60010000080100; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffeffed; ++ *((unsigned long *)&__m256i_op23) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xbf3ffffffffeffed; ++ *((unsigned long *)&__m256i_result2) = 0xbf3ffffffffeffed; ++ *((unsigned long *)&__m256i_result1) = 0xbf3ffffffffeffed; ++ *((unsigned long *)&__m256i_result0) = 0xbf3ffffffffeffed; ++ __m256i_out = __lasx_xvmaddwod_h_bu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0ff80100ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0ff80100ffffffff; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x34000000fff00000; ++ *((unsigned long *)&__m256i_op02) = 0xfff6e00000000000; ++ *((unsigned long *)&__m256i_op01) = 0x3380000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x363c0000fff3c000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffb7146213; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffc1e0049; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffb71c413b; ++ *((unsigned long *)&__m256i_op10) = 0xf3317da580000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x34000000fff00000; ++ *((unsigned long *)&__m256i_result2) = 0xfff6e00000000000; ++ *((unsigned long *)&__m256i_result1) = 0x3380000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x363c0000fff3c000; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffe000ffffffffff; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01c03f8034c03200; ++ *((unsigned long *)&__m256i_op02) = 0x3dc02b400a003400; ++ *((unsigned long *)&__m256i_op01) = 0x01c03f8034c03200; ++ *((unsigned long *)&__m256i_op00) = 0x3dc02b400a003400; ++ *((unsigned long *)&__m256i_op13) = 0x01c03f8034c03200; ++ *((unsigned long *)&__m256i_op12) = 0x3dc02b400a003400; ++ *((unsigned long *)&__m256i_op11) = 0x01c03f8034c03200; ++ *((unsigned long *)&__m256i_op10) = 0x3dc02b400a003400; ++ *((unsigned long *)&__m256i_op23) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op22) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_op21) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op20) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_result3) = 0x01ce3c0050d32d40; ++ *((unsigned long *)&__m256i_result2) = 0x3fadafc013acf600; ++ *((unsigned long *)&__m256i_result1) = 0x01ce3c0050d32d40; ++ *((unsigned long *)&__m256i_result0) = 0x3fadafc013acf600; ++ __m256i_out = __lasx_xvmaddwod_w_hu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op02) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op01) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op00) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op22) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op21) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op20) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_result3) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result2) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result1) = 0xffffffecffffffec; ++ *((unsigned long *)&__m256i_result0) = 0xffffffecffffffec; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000100; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffefd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000100; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xfffffefdfffffefd; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000100; ++ *((unsigned long *)&__m256i_result2) = 0x7fffff7d80000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000100; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000001fdfffffe02; ++ *((unsigned long *)&__m256i_op01) = 0x000000000001fefe; ++ *((unsigned long *)&__m256i_op00) = 0xffff01fefffeff02; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000001fdfffffe02; ++ *((unsigned long *)&__m256i_result1) = 0x000000000001fefe; ++ *((unsigned long *)&__m256i_result0) = 0xffff01fefffeff02; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffdfffffffdffff; ++ *((unsigned long *)&__m256i_op02) = 0xffddffdeffb5ff8d; ++ *((unsigned long *)&__m256i_op01) = 0xfffdfffffffdffff; ++ *((unsigned long *)&__m256i_op00) = 0xffddffdeffb5ff8d; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffffffeeffaf; ++ *((unsigned long *)&__m256i_op12) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffeeffaf; ++ *((unsigned long *)&__m256i_op10) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_op23) = 0xfffdfffffffdffff; ++ *((unsigned long *)&__m256i_op22) = 0xffddffdeffb5ff8d; ++ *((unsigned long *)&__m256i_op21) = 0xfffdfffffffdffff; ++ *((unsigned long *)&__m256i_op20) = 0xffddffdeffb5ff8d; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffcffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0febedc9bb95dd8f; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffcffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0febedc9bb95dd8f; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000545400; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000545400; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fe; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op21) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op02) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_op01) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff7bfffff1; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff80007fe9; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff7bfffff1; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff80007fe9; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0010511c54440437; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0010511c54440437; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000103fca1bd; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000103fca1bd; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000103fca1bd; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000103fca1bd; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result2) = 0x0010511c54440438; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result0) = 0x0010511c54440438; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwod_d_wu (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op12) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op11) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op10) = 0x01fe01fe00000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op01) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op13) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op12) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op11) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op10) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_result3) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_result2) = 0x00000045ff740023; ++ *((unsigned long *)&__m256i_result1) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_result0) = 0x00000045ff740023; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000fffe00800022; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x000000000155b200; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000b70000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000016e00; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000001e001e001e0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000001e001e001e0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaddwev_q_du (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-3.c +new file mode 100644 +index 000000000..5210e4cf9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaddwod-3.c +@@ -0,0 +1,820 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op22) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op21) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op20) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result0) = 0xff01ff01ff01ff01; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000000; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op02) = 0x000b8f81b8c850f4; ++ *((unsigned long *)&__m256i_op01) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op00) = 0x000b8f81b8c850f4; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_op23) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op22) = 0x000b8f81b8c850f4; ++ *((unsigned long *)&__m256i_op21) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_op20) = 0x000b8f81b8c850f4; ++ *((unsigned long *)&__m256i_result3) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_result2) = 0x000b2673a90896a4; ++ *((unsigned long *)&__m256i_result1) = 0x000050504c4c2362; ++ *((unsigned long *)&__m256i_result0) = 0x000b2673a90896a4; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op02) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op00) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffc03fffffffc0; ++ *((unsigned long *)&__m256i_op12) = 0xffffc00000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffc03fffffffc0; ++ *((unsigned long *)&__m256i_op10) = 0xffffc00000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_result2) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_result0) = 0xc600000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff000003c0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff000003c0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000fc300000fc40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7c030000ffc4; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7c030000ffc4; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00f7000000f70006; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00f7000000f70006; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff0007a861; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff0007a861; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_h_bu_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xbff0000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fffffffe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff0002fffeffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff0002fffeffff; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000505; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000001000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000001000; ++ *((unsigned long *)&__m256i_op23) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000627; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000627; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1f60000000c00000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x1f60000000c00000; ++ *((unsigned long *)&__m256i_op23) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000627; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000627; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x437f201f201f2020; ++ *((unsigned long *)&__m256i_op12) = 0x037f201f001f2020; ++ *((unsigned long *)&__m256i_op11) = 0x437f201f201f2020; ++ *((unsigned long *)&__m256i_op10) = 0x037f201f001f2020; ++ *((unsigned long *)&__m256i_op23) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x21bb481000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01bf481000000000; ++ *((unsigned long *)&__m256i_result1) = 0x21bb481000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01bf481000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op22) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_op21) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op20) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x000000ffffff1dff; ++ *((unsigned long *)&__m256i_op22) = 0xffff1dffffff1dff; ++ *((unsigned long *)&__m256i_op21) = 0x000000ffffff1dff; ++ *((unsigned long *)&__m256i_op20) = 0xffff1dffffff1dff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_result2) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_result0) = 0xffff8001ffff0001; ++ __m256i_out ++ = __lasx_xvmaddwod_w_hu_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffe40; ++ *((unsigned long *)&__m256i_op13) = 0x00f9f90079f9f9f9; ++ *((unsigned long *)&__m256i_op12) = 0x79f9f9f900000000; ++ *((unsigned long *)&__m256i_op11) = 0x00f9f90079f9f9f9; ++ *((unsigned long *)&__m256i_op10) = 0x79f9f9f900000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff8c80; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffe40; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op02) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op01) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result2) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_result1) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000089; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffeffffffdd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffdc; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op22) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_op21) = 0x00000000f9f9f9f9; ++ *((unsigned long *)&__m256i_op20) = 0x00000000faf3f3f2; ++ *((unsigned long *)&__m256i_result3) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfbff0000ffff0000; ++ *((unsigned long *)&__m256i_op02) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfbff0000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfbff0000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfbff0000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0101010101010110; ++ *((unsigned long *)&__m256i_op22) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op21) = 0x0101010101010110; ++ *((unsigned long *)&__m256i_op20) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwod_d_wu_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000eef14fe8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0202020201010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000eef14fe8; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0202020201010000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0xfe02fe02fee5fe22; ++ *((unsigned long *)&__m256i_op20) = 0xff49fe4200000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000eef14fe8; ++ *((unsigned long *)&__m256i_result1) = 0xfffe928f1313c9cc; ++ *((unsigned long *)&__m256i_result0) = 0x4244020201010000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op02) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op01) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op00) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result2) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result1) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result0) = 0x0005000500050005; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op23) = 0x3f3f3f3f3f3f3f3f; ++ *((unsigned long *)&__m256i_op22) = 0x3f3f3f3f3f3f3f3f; ++ *((unsigned long *)&__m256i_op21) = 0x000000003f3f3f3f; ++ *((unsigned long *)&__m256i_op20) = 0x3f3f3f3f00000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_result2) = 0xc6c6c6c68787878a; ++ *((unsigned long *)&__m256i_result1) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_result0) = 0x8787878a00000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffff6; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op23) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op22) = 0xc6c6c6c68787878a; ++ *((unsigned long *)&__m256i_op21) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op20) = 0x8787878a00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffe3; ++ *((unsigned long *)&__m256i_result2) = 0x63636344c3c3c4f6; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffc3; ++ *((unsigned long *)&__m256i_result0) = 0xc3c3c500fffffff6; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op12) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op10) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op12) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_op11) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op10) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffbfffcffeffff0; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffbfffcffeffff0; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000b0cfffff4f3; ++ *((unsigned long *)&__m256i_op02) = 0x000f9bb562f56c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000b0cfffff4f3; ++ *((unsigned long *)&__m256i_op00) = 0x000f9bb562f56c80; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op23) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op22) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op21) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op20) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0018761ed60b5d7f; ++ *((unsigned long *)&__m256i_result2) = 0xabdcdc9938afafe9; ++ *((unsigned long *)&__m256i_result1) = 0x0018761ed60b5d7f; ++ *((unsigned long *)&__m256i_result0) = 0xabdcdc9938afafe9; ++ __m256i_out ++ = __lasx_xvmaddwev_q_du_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvldi-xvmskgez-xv.patch
Added
@@ -0,0 +1,2735 @@ +From 8d8564be4eaa8134acab6a184da36f3620a82f6f Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:39:31 +0800 +Subject: PATCH 104/124 LoongArch: Add tests for ASX vector + xvldi/xvmskgez/xvmskltz/xvmsknz/xvmuh /xvsigncov instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvldi.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmskgez.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmskltz.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmsknz.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmuh-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmuh-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsigncov.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvldi.c | 83 +++ + .../loongarch/vector/lasx/lasx-xvmskgez.c | 86 +++ + .../loongarch/vector/lasx/lasx-xvmskltz.c | 373 ++++++++++ + .../loongarch/vector/lasx/lasx-xvmsknz.c | 163 +++++ + .../loongarch/vector/lasx/lasx-xvmuh-1.c | 650 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmuh-2.c | 635 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsigncov.c | 665 ++++++++++++++++++ + 7 files changed, 2655 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskgez.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskltz.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsknz.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsigncov.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldi.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldi.c +new file mode 100644 +index 000000000..84b3c6599 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldi.c +@@ -0,0 +1,83 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_result3) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvldi (-4080); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0xfebcfebcfebcfebc; ++ *((unsigned long *)&__m256i_result2) = 0xfebcfebcfebcfebc; ++ *((unsigned long *)&__m256i_result1) = 0xfebcfebcfebcfebc; ++ *((unsigned long *)&__m256i_result0) = 0xfebcfebcfebcfebc; ++ __m256i_out = __lasx_xvldi (1724); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3fd1000000000000; ++ __m256i_out = __lasx_xvldi (-943); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result2) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result1) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result0) = 0xff1cff1cff1cff1c; ++ __m256i_out = __lasx_xvldi (1820); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_result2) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_result1) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_result0) = 0x7200000072000000; ++ __m256i_out = __lasx_xvldi (-3214); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0xffffff1dffffff1d; ++ *((unsigned long *)&__m256i_result2) = 0xffffff1dffffff1d; ++ *((unsigned long *)&__m256i_result1) = 0xffffff1dffffff1d; ++ *((unsigned long *)&__m256i_result0) = 0xffffff1dffffff1d; ++ __m256i_out = __lasx_xvldi (2845); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvldi (-4080); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3fd1000000000000; ++ __m256i_out = __lasx_xvldi (-943); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_result3) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_result2) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_result1) = 0x7200000072000000; ++ *((unsigned long *)&__m256i_result0) = 0x7200000072000000; ++ __m256i_out = __lasx_xvldi (-3214); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskgez.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskgez.c +new file mode 100644 +index 000000000..15e66ae38 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskgez.c +@@ -0,0 +1,86 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff00; ++ __m256i_out = __lasx_xvmskgez_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvmskgez_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskgez_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskgez_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000203ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000203ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000fafe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000fafe; ++ __m256i_out = __lasx_xvmskgez_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvmskgez_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskltz.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskltz.c +new file mode 100644 +index 000000000..53b21f98b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmskltz.c +@@ -0,0 +1,373 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x3922d40000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000c85221c0; ++ *((unsigned long *)&__m256i_op00) = 0xf7ebfab800000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000f20; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000009f0; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0x40d74f979f99419f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000022; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1f9d9f9d1f9db29f; ++ *((unsigned long *)&__m256i_op02) = 0x1f9d9f9d201cb39e; ++ *((unsigned long *)&__m256i_op01) = 0x201c9f9d201cb29f; ++ *((unsigned long *)&__m256i_op00) = 0x1f9d9f9d201cb39e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007773; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000003373; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc080ffff0049ffd2; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0049ffd2; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffeffb9ff9d; ++ *((unsigned long *)&__m256i_op00) = 0x00630064004bffd0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe0f02081c1c4ce2c; ++ *((unsigned long *)&__m256i_op02) = 0x8008000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xe0f02081c1c4ce2c; ++ *((unsigned long *)&__m256i_op00) = 0x8008000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000b8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000b8; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000003; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op01) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fffc0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000022; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000022; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op02) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op01) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op00) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000088; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000088; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x296e000018170000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x296e000018170000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000404; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000404; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffc000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffeff000c057c; ++ *((unsigned long *)&__m256i_op01) = 0xffffffc000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffeff000c057c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000f0f0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000f0f0; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256i_op01) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffb2f600006f48; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000008c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000008c; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_op02) = 0xffff800300000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff801000000010; ++ *((unsigned long *)&__m256i_op00) = 0xffff800300000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000cc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000cc; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x5); ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffc0; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000055; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000054; ++ __m256i_out = __lasx_xvmskltz_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmskltz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsknz.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsknz.c +new file mode 100644 +index 000000000..81865fd32 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmsknz.c +@@ -0,0 +1,163 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_op02) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_op01) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_op00) = 0x0020002000400040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000005555; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000005555; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000300000002; ++ *((unsigned long *)&__m256i_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000300000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004411; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000004411; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000033; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op02) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op00) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000f91; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000f91; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000001f; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x006018000000001a; ++ *((unsigned long *)&__m256i_op02) = 0x0060401900000000; ++ *((unsigned long *)&__m256i_op01) = 0x006018000000001a; ++ *((unsigned long *)&__m256i_op00) = 0x0060401900000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000006170; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000006170; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000002ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000002ff; ++ __m256i_out = __lasx_xvmsknz_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-1.c +new file mode 100644 +index 000000000..58ad8bfcd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-1.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0xfff0fff0fff0fff0; ++ *((unsigned long *)&__m256i_op01) = 0xfff0fff0ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0xfff0fff0fff0fff0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000007ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000fdfcfda8; ++ *((unsigned long *)&__m256i_op12) = 0x0000e2821d20ffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000fdfcfda8; ++ *((unsigned long *)&__m256i_op10) = 0x0000e2821d20ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffffffffff00; ++ *((unsigned long *)&__m256i_op12) = 0x0000ff8000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffffff00; ++ *((unsigned long *)&__m256i_op10) = 0x0000ff8000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x372e9d75e8aab100; ++ *((unsigned long *)&__m256i_op02) = 0xc5c085372cfabfba; ++ *((unsigned long *)&__m256i_op01) = 0x31730b5beb7c99f5; ++ *((unsigned long *)&__m256i_op00) = 0x0658f2dc0eb21e3c; ++ *((unsigned long *)&__m256i_op13) = 0x000019410000e69a; ++ *((unsigned long *)&__m256i_op12) = 0xf259905a0c126604; ++ *((unsigned long *)&__m256i_op11) = 0x0000883a00000f20; ++ *((unsigned long *)&__m256i_op10) = 0x6d3c2d3aa1c82947; ++ *((unsigned long *)&__m256i_result3) = 0x0000f647000007d6; ++ *((unsigned long *)&__m256i_result2) = 0x031b358c021ee663; ++ *((unsigned long *)&__m256i_result1) = 0x0000faaf0000f9f8; ++ *((unsigned long *)&__m256i_result0) = 0x02b4fdadfa9704df; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xf7ffffffffffff1f; ++ *((unsigned long *)&__m256i_op12) = 0xbffffffffffffeff; ++ *((unsigned long *)&__m256i_op11) = 0xf7ffffffffffff1f; ++ *((unsigned long *)&__m256i_op10) = 0xbffffffffffffeff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffe05fc47b400; ++ *((unsigned long *)&__m256i_op12) = 0xfffffe06003fc000; ++ *((unsigned long *)&__m256i_op11) = 0xfffffe05fc47b400; ++ *((unsigned long *)&__m256i_op10) = 0xfffffe06003fc000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffff8900000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff8900000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256i_op02) = 0x0000aaaa0000aaaa; ++ *((unsigned long *)&__m256i_op01) = 0x0000aaaa00008bfe; ++ *((unsigned long *)&__m256i_op00) = 0x0000aaaa0000aaaa; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff5556aaaa; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff5556aaaa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000001fff0; ++ *((unsigned long *)&__m256i_op02) = 0x0000feff0001ffb8; ++ *((unsigned long *)&__m256i_op01) = 0x000000000001fff0; ++ *((unsigned long *)&__m256i_op00) = 0x0000feff0001ffb8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffe000ffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op12) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op11) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op10) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000000007fffe; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000036a37; ++ *((unsigned long *)&__m256i_op11) = 0x000000000007fffe; ++ *((unsigned long *)&__m256i_op10) = 0x000000000004def9; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmuh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fffe0001; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffe0001; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fffe0001; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffe0001; ++ __m256i_out = __lasx_xvmuh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op02) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op01) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op00) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op13) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op12) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op11) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op10) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result3) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_result2) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_result1) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_result0) = 0x000408080c111414; ++ __m256i_out = __lasx_xvmuh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op12) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op11) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op10) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-2.c +new file mode 100644 +index 000000000..85d24fe44 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmuh-2.c +@@ -0,0 +1,635 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_result3) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result2) = 0xfe8bfe0efe8bfe12; ++ *((unsigned long *)&__m256i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0xfe8bfe0efe8bfe12; ++ __m256i_out = __lasx_xvmuh_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000027; ++ __m256i_out = __lasx_xvmuh_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op02) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op02) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_op01) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op00) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00020002ff820002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00020002ff820002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x40efffe09fa88260; ++ *((unsigned long *)&__m256i_op02) = 0x6b07ca8e013fbf01; ++ *((unsigned long *)&__m256i_op01) = 0x40efffe09fa7e358; ++ *((unsigned long *)&__m256i_op00) = 0x80ce32be3e827f00; ++ *((unsigned long *)&__m256i_op13) = 0x86ff76ffff4eff42; ++ *((unsigned long *)&__m256i_op12) = 0x86ffffffffff9eff; ++ *((unsigned long *)&__m256i_op11) = 0x86ff76ffff4effff; ++ *((unsigned long *)&__m256i_op10) = 0x86ff32ffaeffffa0; ++ *((unsigned long *)&__m256i_result3) = 0x223d76f09f3881ff; ++ *((unsigned long *)&__m256i_result2) = 0x3870ca8d013e76a0; ++ *((unsigned long *)&__m256i_result1) = 0x223d76f09f37e357; ++ *((unsigned long *)&__m256i_result0) = 0x43ec0a1b2aba7ed0; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op12) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op11) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_op10) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffc020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffc020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000001400000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000001400000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x5fa0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x5fa0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0f00204000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0c6a240000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0f00204000000000; ++ *((unsigned long *)&__m256i_result3) = 0x04a3000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x04a3000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x80ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x80ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff8000fffe; ++ *((unsigned long *)&__m256i_op12) = 0x0001fffe00017fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff8000fffe; ++ *((unsigned long *)&__m256i_op10) = 0x0001fffe00017fff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000007f00fe; ++ *((unsigned long *)&__m256i_result2) = 0x000000fe0000007f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000007f00fe; ++ *((unsigned long *)&__m256i_result0) = 0x000000fe0000007f; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffe00000ffe00000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffe00000ffe00000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_op12) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_op11) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_op10) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000fafe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000fafe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op12) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op11) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op10) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff01c000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0x00000000f1000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000001341c4000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000001000310000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000033e87ef1; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000002e2100; ++ __m256i_out = __lasx_xvmuh_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op12) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op11) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op10) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result3) = 0x000000000045f3fb; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000045f3fb; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_op13) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op11) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7575ffff75757595; ++ *((unsigned long *)&__m256i_op02) = 0x7575ffff7575f575; ++ *((unsigned long *)&__m256i_op01) = 0x7575ffff75757595; ++ *((unsigned long *)&__m256i_op00) = 0x7575ffff7575f575; ++ *((unsigned long *)&__m256i_op13) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x3aadec4f6c7975b1; ++ *((unsigned long *)&__m256i_result2) = 0x3abac5447fffca89; ++ *((unsigned long *)&__m256i_result1) = 0x3aadec4f6c7975b1; ++ *((unsigned long *)&__m256i_result0) = 0x3abac5447fffca89; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000003f; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_op11) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_result3) = 0x000000000010000f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000010000f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmuh_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsigncov.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsigncov.c +new file mode 100644 +index 000000000..2a6eee0fd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsigncov.c +@@ -0,0 +1,665 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_op02) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_op01) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_op00) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffff605a; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffff605a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0101000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0101000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op02) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff39ffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff39ffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_op12) = 0x0202810102020202; ++ *((unsigned long *)&__m256i_op11) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_op10) = 0x0202810102020202; ++ *((unsigned long *)&__m256i_result3) = 0x0000fefe0000fefe; ++ *((unsigned long *)&__m256i_result2) = 0x00007fff0000fefe; ++ *((unsigned long *)&__m256i_result1) = 0x0000fefe0000fefe; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff0000fefe; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000017547fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000017547fffffff; ++ *((unsigned long *)&__m256i_op13) = 0x807e80fd80fe80fd; ++ *((unsigned long *)&__m256i_op12) = 0x80938013800d8002; ++ *((unsigned long *)&__m256i_op11) = 0x807e80fd80fe0000; ++ *((unsigned long *)&__m256i_op10) = 0x80938013800d0005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000801380f380fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000801380f300fb; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffd5a98; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000101ff01; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op12) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op10) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffee; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff80ff00ff80ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff80ff00ff80ff01; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000fd; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fd; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8011ffee804c004c; ++ *((unsigned long *)&__m256i_op02) = 0x00faff0500c3ff3c; ++ *((unsigned long *)&__m256i_op01) = 0x80f900f980780078; ++ *((unsigned long *)&__m256i_op00) = 0x0057ffa800ceff31; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff000000010000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3880800037800000; ++ *((unsigned long *)&__m256i_op02) = 0x3901000039010000; ++ *((unsigned long *)&__m256i_op01) = 0x3880800037800000; ++ *((unsigned long *)&__m256i_op00) = 0x3901000039010000; ++ *((unsigned long *)&__m256i_op13) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op12) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op11) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op10) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_result3) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_result2) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_result1) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_result0) = 0x00003fc00000428a; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_op02) = 0xfffe0000fffe0012; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffeffee; ++ *((unsigned long *)&__m256i_op00) = 0xfffe0000fffe0012; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000001ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000001ffff; ++ __m256i_out = __lasx_xvsigncov_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x80be0000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x80be0000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000100000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000100000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff00000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_op02) = 0xdfc2df80df80df87; ++ *((unsigned long *)&__m256i_op01) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_op00) = 0xdfc2df80df80df87; ++ *((unsigned long *)&__m256i_op13) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_op12) = 0xdfc2df80df80df87; ++ *((unsigned long *)&__m256i_op11) = 0xdf80df80df80df80; ++ *((unsigned long *)&__m256i_op10) = 0xdfc2df80df80df87; ++ *((unsigned long *)&__m256i_result3) = 0x2080208020802080; ++ *((unsigned long *)&__m256i_result2) = 0x203e208020802079; ++ *((unsigned long *)&__m256i_result1) = 0x2080208020802080; ++ *((unsigned long *)&__m256i_result0) = 0x203e208020802079; ++ __m256i_out = __lasx_xvsigncov_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003f3f00004040; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffe05f8102; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000004e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_op13) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_op12) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_op11) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_op10) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_result3) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_result2) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_result1) = 0xffffba8300004fc2; ++ *((unsigned long *)&__m256i_result0) = 0xffffba8300004fc2; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x004100df00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00c000000000; ++ *((unsigned long *)&__m256i_op01) = 0x004100df00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00c000000000; ++ *((unsigned long *)&__m256i_op13) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op12) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_op11) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op10) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_result3) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_result2) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_result1) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_result0) = 0xc1d75053f0000000; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffa30000165a; ++ *((unsigned long *)&__m256i_op02) = 0x0000104000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffa30000165a; ++ *((unsigned long *)&__m256i_op00) = 0x0000104000000000; ++ *((unsigned long *)&__m256i_op13) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op12) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_op11) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m256i_op10) = 0xc1d75053f0000000; ++ *((unsigned long *)&__m256i_result3) = 0xbe21000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000505300000000; ++ *((unsigned long *)&__m256i_result1) = 0xbe21000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000505300000000; ++ __m256i_out = __lasx_xvsigncov_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000001880310877e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000001880310877e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000f788f788; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000f788f788; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op12) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result3) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op02) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op00) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000001faf19b60; ++ *((unsigned long *)&__m256i_op12) = 0x6c2905ae7c14c561; ++ *((unsigned long *)&__m256i_op11) = 0x00000001faf19b60; ++ *((unsigned long *)&__m256i_op10) = 0x6c2905ae7c14c561; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x94d7fb5200000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x94d7fb5200000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256i_op12) = 0xfffe97a1df5b41b0; ++ *((unsigned long *)&__m256i_op11) = 0xfffeb664007ffd61; ++ *((unsigned long *)&__m256i_op10) = 0xfffe97a1df5b41b0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000180; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsigncov_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_op02) = 0x8768876887688769; ++ *((unsigned long *)&__m256i_op01) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_op00) = 0x8768876887688769; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000003fffc0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000003fffc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffc00040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffc00040; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffdbff980038ffaf; ++ *((unsigned long *)&__m256i_op02) = 0xffafffe80004fff1; ++ *((unsigned long *)&__m256i_op01) = 0xffdbff980038ffaf; ++ *((unsigned long *)&__m256i_op00) = 0xffafffe80004fff1; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffc; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000fffd0003; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffc; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000fffd0003; ++ *((unsigned long *)&__m256i_result3) = 0xffff0000fffd0004; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_result1) = 0xffff0000fffd0004; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0002fffd; ++ __m256i_out = __lasx_xvsigncov_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvmax-xvmaxi-xvmi.patch
Added
@@ -0,0 +1,4124 @@ +From 00deb43164bce9740d6e2e103afce647bebc6ee3 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:31:02 +0800 +Subject: PATCH 103/124 LoongArch: Add tests for ASX vector + xvmax/xvmaxi/xvmin/xvmini instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvmax-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmax-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaxi-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmaxi-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmin-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmin-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmini-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmini-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvmax-1.c | 545 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmax-2.c | 560 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaxi-1.c | 471 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvmaxi-2.c | 504 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvmin-1.c | 575 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmin-2.c | 680 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmini-1.c | 416 +++++++++++ + .../loongarch/vector/lasx/lasx-xvmini-2.c | 284 ++++++++ + 8 files changed, 4035 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-1.c +new file mode 100644 +index 000000000..96c6671f2 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-1.c +@@ -0,0 +1,545 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f0000007f000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7f0000007f000000; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff000000; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff000000000000; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0004000400040004; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x5900000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x5900000000000000; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ffce20; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ffce20; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ee1100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000004560408; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ee1100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000004560408; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000004560420; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000004560420; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000001ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f433c78; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op02) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op01) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op00) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffce; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7ff0000000000000; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00ff00ff; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x4000000000000000; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff800080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000400010004; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000400010004; ++ *((unsigned long *)&__m256i_result3) = 0x0001000e0001000e; ++ *((unsigned long *)&__m256i_result2) = 0x0001000e0001000e; ++ *((unsigned long *)&__m256i_result1) = 0x0001000e0001000e; ++ *((unsigned long *)&__m256i_result0) = 0x0001000e0001000e; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1090918800000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1090918800000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1c80780000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op11) = 0x1c80780000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x1c80780000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result1) = 0x1c80780000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000004000; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op12) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op11) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op10) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op12) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op11) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op10) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result3) = 0x000000007f7f817f; ++ *((unsigned long *)&__m256i_result2) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result1) = 0x000000007f7f817f; ++ *((unsigned long *)&__m256i_result0) = 0x7f807f007f7f817f; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffebeeaaefafb; ++ *((unsigned long *)&__m256i_op12) = 0xfffffebeeaaeeeeb; ++ *((unsigned long *)&__m256i_op11) = 0xfffffebeeaaefafb; ++ *((unsigned long *)&__m256i_op10) = 0xfffffebeeaaeeeeb; ++ *((unsigned long *)&__m256i_result3) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op02) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op01) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op00) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff00; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_op12) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_op10) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_result2) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_result0) = 0x7fff00007fff0000; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvmax_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_op12) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_op11) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_op10) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_result3) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_result2) = 0x556caad9aabbaa88; ++ *((unsigned long *)&__m256i_result1) = 0x0000004a557baac4; ++ *((unsigned long *)&__m256i_result0) = 0x556caad9aabbaa88; ++ __m256i_out = __lasx_xvmax_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000020006; ++ __m256i_out = __lasx_xvmax_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op12) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op11) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op10) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result3) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_result2) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result1) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_result0) = 0xfffe97c020010001; ++ __m256i_out = __lasx_xvmax_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-2.c +new file mode 100644 +index 000000000..38f2c0afe +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmax-2.c +@@ -0,0 +1,560 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffdfffffffdfffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffdfffffffdfffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffee0000ff4c; ++ *((unsigned long *)&__m256i_op12) = 0x0000ff050000ff3c; ++ *((unsigned long *)&__m256i_op11) = 0x0000fff90000ff78; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffa80000ff31; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op02) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op00) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result2) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result0) = 0x817f11ed81800ff0; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003fe000000000; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x800000ff800000ff; ++ __m256i_out = __lasx_xvmax_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256i_op02) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000001; ++ *((unsigned long *)&__m256i_op00) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffeeffaf; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffeeffaf; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffffffeeffaf; ++ *((unsigned long *)&__m256i_result2) = 0x1010100f10100fd4; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffffeeffaf; ++ *((unsigned long *)&__m256i_result0) = 0x1010100f10100fd4; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op12) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op10) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_result3) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_result2) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_result0) = 0xf0f0f0f0f0f0f0f0; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op12) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op10) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_result2) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_result0) = 0xc600000000000000; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_op13) = 0x0000d0d8ffffeecf; ++ *((unsigned long *)&__m256i_op12) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256i_op11) = 0x0000d0d8ffffeecf; ++ *((unsigned long *)&__m256i_op10) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffd8ffc7ffffdf0d; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffd8ffc7ffffdf0d; ++ __m256i_out = __lasx_xvmax_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000003f8000004; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000003f8000004; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000003f8000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000003f8000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000014402080144; ++ __m256i_out = __lasx_xvmax_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000a0008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000a0008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f433c78; ++ __m256i_out = __lasx_xvmax_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff97a2; ++ __m256i_out = __lasx_xvmax_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op12) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op11) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op10) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x000000070002000a; ++ __m256i_out = __lasx_xvmax_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op13) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op12) = 0xfffcf800fffcf800; ++ *((unsigned long *)&__m256i_op11) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op10) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result2) = 0xfffcf800fffcf800; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result0) = 0x0000080000000800; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000005e02; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000005e02; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op13) = 0xffffc7418a023680; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffff8845bb954b00; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffc7418a023680; ++ *((unsigned long *)&__m256i_result2) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_result1) = 0xffff8845bb954b00; ++ *((unsigned long *)&__m256i_result0) = 0x00000000002a5429; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_op02) = 0x000000003f800000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_op00) = 0x000000003f800000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000040404040; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000001400; ++ *((unsigned long *)&__m256i_op02) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffff08a7de0; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffff07c4170; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffff08a7de0; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffff07c4170; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffff08a7de0; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffff07c4170; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffff08a7de0; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffff07c4170; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmax_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-1.c +new file mode 100644 +index 000000000..e804a0a45 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-1.c +@@ -0,0 +1,471 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffd10000006459; ++ *((unsigned long *)&__m256i_op02) = 0x0000441000000004; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op00) = 0x0000040400000104; ++ *((unsigned long *)&__m256i_result3) = 0x0f0f0f0f0f0f6459; ++ *((unsigned long *)&__m256i_result2) = 0x0f0f44100f0f0f0f; ++ *((unsigned long *)&__m256i_result1) = 0x0f0f0f0f0f0f0f0f; ++ *((unsigned long *)&__m256i_result0) = 0x0f0f0f0f0f0f0f0f; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8080808180808093; ++ *((unsigned long *)&__m256i_op02) = 0x80808081808080fe; ++ *((unsigned long *)&__m256i_op01) = 0x8080808180808093; ++ *((unsigned long *)&__m256i_op00) = 0x80808081808080fb; ++ *((unsigned long *)&__m256i_result3) = 0xf5f5f5f5f5f5f5f5; ++ *((unsigned long *)&__m256i_result2) = 0xf5f5f5f5f5f5f5fe; ++ *((unsigned long *)&__m256i_result1) = 0xf5f5f5f5f5f5f5f5; ++ *((unsigned long *)&__m256i_result0) = 0xf5f5f5f5f5f5f5fb; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_result2) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_result1) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_result0) = 0x0909090909090909; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result3) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result2) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result1) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result0) = 0x0d0d0d0d0d0d0d0d; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_result2) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_result1) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_result0) = 0x0a0a0a0a7f0a0a0a; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0707070707070707; ++ *((unsigned long *)&__m256i_result2) = 0x0707070707070707; ++ *((unsigned long *)&__m256i_result1) = 0x0707070707070707; ++ *((unsigned long *)&__m256i_result0) = 0x0707070707070707; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result2) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result1) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result0) = 0x0d0d0d0d0d0d0d0d; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_op02) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_op01) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_op00) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_result3) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_result2) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_result1) = 0x2a2a2a2a2a2a2a2a; ++ *((unsigned long *)&__m256i_result0) = 0x2a2a2a2a2a2a2a2a; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0c0c0c0c0c0c0c0c; ++ *((unsigned long *)&__m256i_result2) = 0x0c0c0c0c0c0c0c0c; ++ *((unsigned long *)&__m256i_result1) = 0x0c0c0c0c0c0c0c0c; ++ *((unsigned long *)&__m256i_result0) = 0x0c0c0c0c0c0c0c0c; ++ __m256i_out = __lasx_xvmaxi_b (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result2) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result1) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result0) = 0x0005000500050005; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op02) = 0xffc00000ffc0ffc0; ++ *((unsigned long *)&__m256i_op01) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op00) = 0xffc00000ffc0ffc0; ++ *((unsigned long *)&__m256i_result3) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_result2) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_result1) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_result0) = 0xfff90000fff9fff9; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00040000; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00080008000801ff; ++ *((unsigned long *)&__m256i_result2) = 0x0008000800080008; ++ *((unsigned long *)&__m256i_result1) = 0x00080008000801ff; ++ *((unsigned long *)&__m256i_result0) = 0x0008000800080008; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, 8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000c9; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op02) = 0x000000008000165a; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op00) = 0x000000008000165a; ++ *((unsigned long *)&__m256i_result3) = 0x0009000900090009; ++ *((unsigned long *)&__m256i_result2) = 0x000900090009165a; ++ *((unsigned long *)&__m256i_result1) = 0x0009000900090009; ++ *((unsigned long *)&__m256i_result0) = 0x000900090009165a; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op02) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op01) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op00) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_result3) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_result2) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_result1) = 0x000a000a000a000a; ++ *((unsigned long *)&__m256i_result0) = 0x000a000a000a000a; ++ __m256i_out = __lasx_xvmaxi_h (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000401000000; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0110000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0110000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0110000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0110000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x0110000000000004; ++ *((unsigned long *)&__m256i_result2) = 0x0110000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0110000000000004; ++ *((unsigned long *)&__m256i_result0) = 0x0110000000000080; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_result2) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_result0) = 0x0000000e0000000e; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff400000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff400000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000900000009; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result2) = 0x000000081f20607a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m256i_result0) = 0x000000081f20607a; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, 8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmaxi_w (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_op02) = 0x0000000004560420; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_op00) = 0x0000000004560420; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_result2) = 0x0000000004560420; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000004560420; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_op02) = 0x7e00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_op00) = 0x7e00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_result2) = 0x7e00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007e1c7e1c; ++ *((unsigned long *)&__m256i_result0) = 0x7e00000000000000; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff5; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff5; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffff5; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff5; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007b007e; ++ __m256i_out = __lasx_xvmaxi_d (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-2.c +new file mode 100644 +index 000000000..b6b34063c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmaxi-2.c +@@ -0,0 +1,504 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000102; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0a0a0a0a0a0a0a0a; ++ *((unsigned long *)&__m256i_result2) = 0x0a0a0a0a0a0a0a0a; ++ *((unsigned long *)&__m256i_result1) = 0x0a0a0a0a0a0a0a0a; ++ *((unsigned long *)&__m256i_result0) = 0x0a0a0a0a0a0a0a0a; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_result2) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_result1) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_result0) = 0x1717171717171717; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe00007f000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x1616161616161616; ++ *((unsigned long *)&__m256i_result2) = 0x161616167fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7ffe16167f161616; ++ *((unsigned long *)&__m256i_result0) = 0x161616167fffffff; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000feb60000b7d0; ++ *((unsigned long *)&__m256i_op02) = 0x0000feb60000c7eb; ++ *((unsigned long *)&__m256i_op01) = 0x0000feb60000b7d0; ++ *((unsigned long *)&__m256i_op00) = 0x0000feb60000c7eb; ++ *((unsigned long *)&__m256i_result3) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_result2) = 0x0707feb60707c7eb; ++ *((unsigned long *)&__m256i_result1) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_result0) = 0x0707feb60707c7eb; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_result2) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_result1) = 0x1111111111111111; ++ *((unsigned long *)&__m256i_result0) = 0x1111111111111111; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffa3; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000165a; ++ *((unsigned long *)&__m256i_result3) = 0x1818ffff1818ffa3; ++ *((unsigned long *)&__m256i_result2) = 0x181818181818185a; ++ *((unsigned long *)&__m256i_result1) = 0x1818ffff1818ffa3; ++ *((unsigned long *)&__m256i_result0) = 0x181818181818185a; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_result2) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_result1) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_result0) = 0x1c1c1c1c1c1c1c1c; ++ __m256i_out = __lasx_xvmaxi_bu (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaxi_hu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xeffc000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xf064c6098d214127; ++ *((unsigned long *)&__m256i_op01) = 0xeffc000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xf064c6098d214127; ++ *((unsigned long *)&__m256i_result3) = 0xeffc001800180018; ++ *((unsigned long *)&__m256i_result2) = 0xf064c6098d214127; ++ *((unsigned long *)&__m256i_result1) = 0xeffc001800180018; ++ *((unsigned long *)&__m256i_result0) = 0xf064c6098d214127; ++ __m256i_out = __lasx_xvmaxi_hu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010003; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010003; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvmaxi_hu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_result2) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_result1) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_result0) = 0x0007000700070007; ++ __m256i_out = __lasx_xvmaxi_hu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0018001800180018; ++ *((unsigned long *)&__m256i_result2) = 0x0018001800180018; ++ *((unsigned long *)&__m256i_result1) = 0x0018001800180018; ++ *((unsigned long *)&__m256i_result0) = 0x0018001800180018; ++ __m256i_out = __lasx_xvmaxi_hu (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result3) = 0x0017001700176d6d; ++ *((unsigned long *)&__m256i_result2) = 0x0017001700176d6d; ++ *((unsigned long *)&__m256i_result1) = 0x0017001700176d6d; ++ *((unsigned long *)&__m256i_result0) = 0x0017001700176d6d; ++ __m256i_out = __lasx_xvmaxi_hu (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x001fffffffe00000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x001fffffffe00011; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x001fffffffe00011; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvmaxi_hu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result2) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result1) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result0) = 0x0000001400000014; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000e00000080; ++ *((unsigned long *)&__m256i_result2) = 0x0000000e00000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000e00000080; ++ *((unsigned long *)&__m256i_result0) = 0x0000000e00000080; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000fd0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000fd0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_result2) = 0x0000001b00fd0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_result0) = 0x0000001b00fd0000; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_op01) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000c7aff7c00; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000c7aff7c00; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffd017d00; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000001f0000001f; ++ *((unsigned long *)&__m256i_result0) = 0x0000001f0000ffff; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000300000003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000300000003; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1010101010001000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x1010101000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x1010101010001000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x101010100000000e; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000007ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000001e0007ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000001e0007ffff; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000fd; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result2) = 0x00000004000000fd; ++ *((unsigned long *)&__m256i_result1) = 0x00000004000000fe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000400000004; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000001f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000001f; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000001700000017; ++ *((unsigned long *)&__m256i_result2) = 0x0000001700000017; ++ *((unsigned long *)&__m256i_result1) = 0x0000001700000017; ++ *((unsigned long *)&__m256i_result0) = 0x0000001700000017; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op02) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_op01) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op00) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_result3) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_result2) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_result1) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_result0) = 0x07fed3c8f7ad28d0; ++ __m256i_out = __lasx_xvmaxi_wu (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000001e; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000001e; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op02) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op01) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op00) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result3) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result2) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result1) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result0) = 0x1c1b1a191c1b1a19; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000003f; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000001c; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000001c; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000001c; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000001c; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000005; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000600000006; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffffe; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000012; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000000b; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000b; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000013; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000014; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000014; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000014; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000014; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000014; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000014; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000014; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000014; ++ __m256i_out = __lasx_xvmaxi_du (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-1.c +new file mode 100644 +index 000000000..7dbf335c1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-1.c +@@ -0,0 +1,575 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8001000080000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000800080000728; ++ *((unsigned long *)&__m256i_op11) = 0x8001800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x800080008000b8f1; ++ *((unsigned long *)&__m256i_result3) = 0x8000ffff8000ffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff80008000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x800080008000b8f1; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op02) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_op01) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_op13) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_op11) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_result3) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_result2) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_result1) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_result0) = 0x0000000180007fe8; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op12) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_op11) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op10) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_result3) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_result2) = 0x8800c800c800c801; ++ *((unsigned long *)&__m256i_result1) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_result0) = 0x8800c800c800c801; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7070545438381c1c; ++ *((unsigned long *)&__m256i_op02) = 0x7070545438381c1c; ++ *((unsigned long *)&__m256i_op01) = 0x7070545438381c1c; ++ *((unsigned long *)&__m256i_op00) = 0x7070545438381c1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffff00ffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00ffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffff00ffff8000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffff00ffff8000; ++ __m256i_out = __lasx_xvmin_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x003ff18080010201; ++ *((unsigned long *)&__m256i_op02) = 0x0100000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x003ff18080010201; ++ *((unsigned long *)&__m256i_op00) = 0x0100000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000f18080010000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000f18080010000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000d24; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op12) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op11) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op10) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000fffe; ++ __m256i_out = __lasx_xvmin_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff81ff7d; ++ __m256i_out = __lasx_xvmin_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmin_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000017f7f7f7f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000017f7f7f7f; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmin_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op02) = 0x0000000004040104; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffd1108199; ++ *((unsigned long *)&__m256i_op00) = 0x00000000714910f9; ++ *((unsigned long *)&__m256i_op13) = 0xffffd10000006459; ++ *((unsigned long *)&__m256i_op12) = 0x0000441000000004; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op10) = 0x0000040400000104; ++ *((unsigned long *)&__m256i_result3) = 0xffffd10000000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffd1108199; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000104; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_op11) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00010003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0100; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x0000fd00ffff02ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001fffeff; ++ *((unsigned long *)&__m256i_op10) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff02ff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0100; ++ *((unsigned long *)&__m256i_result0) = 0xff00fe00feff02ff; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op02) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op01) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op00) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff1f001f; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffe1ffe0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff1f001f; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffe1ffe0; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0xf000f00000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0xf000f00000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xf000f00000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xf000f00000000001; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff0102; ++ *((unsigned long *)&__m256i_op02) = 0x007c000000810081; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff0102; ++ *((unsigned long *)&__m256i_op00) = 0x007c000000810081; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4545454545454545; ++ *((unsigned long *)&__m256i_op02) = 0x4545454545454545; ++ *((unsigned long *)&__m256i_op01) = 0x4545454545454545; ++ *((unsigned long *)&__m256i_op00) = 0x4545454545454545; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffbfffffffb; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffbfffffffb; ++ __m256i_out = __lasx_xvmin_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-2.c +new file mode 100644 +index 000000000..9eaa0e9e7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmin-2.c +@@ -0,0 +1,680 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x007f017f807f017d; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x007f017f807f017f; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result2) = 0x0000017f0000017d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result0) = 0x0000017f0000017f; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7f70000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7f70000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000002080100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000002080100; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00ff0000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00ff0000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000001de2dc20; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000001de2dc20; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000010100; ++ *((unsigned long *)&__m256i_op00) = 0x0001000001000100; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffbf7f7fff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffe651bfff; ++ *((unsigned long *)&__m256i_result3) = 0x0001010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000010100; ++ *((unsigned long *)&__m256i_result0) = 0x0001000001000100; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256i_op02) = 0x0000468600007f79; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000f3280000dfff; ++ *((unsigned long *)&__m256i_op13) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_op12) = 0x1d1d1d1ddd9d9d1d; ++ *((unsigned long *)&__m256i_op11) = 0x1d1d1d1d1d1d1d1d; ++ *((unsigned long *)&__m256i_op10) = 0x1d1d1d1d046fdd1d; ++ *((unsigned long *)&__m256i_result3) = 0x00001d1d00001d1d; ++ *((unsigned long *)&__m256i_result2) = 0x00001d1d00007f79; ++ *((unsigned long *)&__m256i_result1) = 0x00001d1d00001d1d; ++ *((unsigned long *)&__m256i_result0) = 0x00001d1d0000dd1d; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op02) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op00) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0106010601060106; ++ *((unsigned long *)&__m256i_op02) = 0x0106010601060106; ++ *((unsigned long *)&__m256i_op01) = 0x0106010601060106; ++ *((unsigned long *)&__m256i_op00) = 0x0106010601060106; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00011ffb0000bee1; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00011ffb0000bee1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001010600000106; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001010600000106; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffd5d5ffffd5d6; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffd5d5ffffd5d6; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8b1414140e0e0e0e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x36722a7e66972cd6; ++ *((unsigned long *)&__m256i_op13) = 0xc58a0a0a07070706; ++ *((unsigned long *)&__m256i_op12) = 0x006b60e4180b0023; ++ *((unsigned long *)&__m256i_op11) = 0x1b39153f334b966a; ++ *((unsigned long *)&__m256i_op10) = 0xf1d75d79efcac002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x006b60e40e0e0e0e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x36722a7e66972cd6; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000101ff01; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00040000; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00010e0d00009e0e; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00009000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000e0e; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00009000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000033; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000033; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256i_op12) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffe36780; ++ *((unsigned long *)&__m256i_op10) = 0x8000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op12) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00f0000000f00010; ++ *((unsigned long *)&__m256i_op12) = 0xfff0ff00fff0ff10; ++ *((unsigned long *)&__m256i_op11) = 0x00f0000000f00010; ++ *((unsigned long *)&__m256i_op10) = 0xfff0ff00fff0ff10; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_op12) = 0x0000400100004001; ++ *((unsigned long *)&__m256i_op11) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_op10) = 0x0000400100004001; ++ *((unsigned long *)&__m256i_result3) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_result2) = 0x0000400100004001; ++ *((unsigned long *)&__m256i_result1) = 0x0000400000003ffb; ++ *((unsigned long *)&__m256i_result0) = 0x0000400100004001; ++ __m256i_out = __lasx_xvmin_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x60f02081c1c4ce2c; ++ *((unsigned long *)&__m256i_op02) = 0x8008000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x60f02081c1c4ce2c; ++ *((unsigned long *)&__m256i_op00) = 0x8008000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010183f9999b; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x01010101d58f43c9; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0101010183f9999b; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x01010101d58f43c9; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff00ff00ee; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00ff00ee; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007f00ff007f00ff; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op02) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op01) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op00) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007f7f7f7f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007f7f7f7f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000001fffe; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmin_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-1.c +new file mode 100644 +index 000000000..01aabada8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-1.c +@@ -0,0 +1,416 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xf96d674800000000; ++ *((unsigned long *)&__m256i_op02) = 0x44a4330e2c7116c0; ++ *((unsigned long *)&__m256i_op01) = 0x14187a7822b653c0; ++ *((unsigned long *)&__m256i_op00) = 0xfbe0b866962b96d0; ++ *((unsigned long *)&__m256i_result3) = 0xf90c0c0c00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0ca40c0c0c0c0cc0; ++ *((unsigned long *)&__m256i_result1) = 0x0c0c0c0c0cb60cc0; ++ *((unsigned long *)&__m256i_result0) = 0xfbe0b80c960c96d0; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010bfc80010bf52; ++ *((unsigned long *)&__m256i_op02) = 0xfff1bfca0011bfcb; ++ *((unsigned long *)&__m256i_op01) = 0x0010bfc80010bf52; ++ *((unsigned long *)&__m256i_op00) = 0xfff1bfca0011bfcb; ++ *((unsigned long *)&__m256i_result3) = 0xf5f5bfc8f5f5bff5; ++ *((unsigned long *)&__m256i_result2) = 0xf5f1bfcaf5f5bfcb; ++ *((unsigned long *)&__m256i_result1) = 0xf5f5bfc8f5f5bff5; ++ *((unsigned long *)&__m256i_result0) = 0xf5f1bfcaf5f5bfcb; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m256i_result2) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m256i_result1) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m256i_result0) = 0xf8f8f8f8f8f8f8f8; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000aaabffff; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff47b4ffff5878; ++ *((unsigned long *)&__m256i_op02) = 0x0000b84b0000a787; ++ *((unsigned long *)&__m256i_op01) = 0xffff47b4ffff5878; ++ *((unsigned long *)&__m256i_op00) = 0x0000b84b0000a787; ++ *((unsigned long *)&__m256i_result3) = 0xffff07b4ffff0707; ++ *((unsigned long *)&__m256i_result2) = 0x0000b8070000a787; ++ *((unsigned long *)&__m256i_result1) = 0xffff07b4ffff0707; ++ *((unsigned long *)&__m256i_result0) = 0x0000b8070000a787; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result2) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result0) = 0xf7f7f7f7f7f7f7f7; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_result2) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_result1) = 0xf3f3f3f3f3f3f3f3; ++ *((unsigned long *)&__m256i_result0) = 0xf3f3f3f3f3f3f3f3; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result2) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result1) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_result0) = 0xf9f9f9f9f9f9f9f9; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op02) = 0xc30e0000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op00) = 0xc30e0000ff800000; ++ *((unsigned long *)&__m256i_result3) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_result2) = 0xc3030000ff800000; ++ *((unsigned long *)&__m256i_result1) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_result0) = 0xc3030000ff800000; ++ __m256i_out = __lasx_xvmini_b (__m256i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_result2) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_result1) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_result0) = 0xfff6fff6fff6fff6; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1fffffff1fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0383634303836343; ++ *((unsigned long *)&__m256i_op01) = 0x1fffffff1fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0383634303836343; ++ *((unsigned long *)&__m256i_result3) = 0x0002ffff0002ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result1) = 0x0002ffff0002ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0002000200020002; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000f7bc0001f7bd; ++ *((unsigned long *)&__m256i_op02) = 0x0000f93b0000017c; ++ *((unsigned long *)&__m256i_op01) = 0x0000f7bc0001f7bd; ++ *((unsigned long *)&__m256i_op00) = 0x0000f93b0000017b; ++ *((unsigned long *)&__m256i_result3) = 0xfff2f7bcfff2f7bd; ++ *((unsigned long *)&__m256i_result2) = 0xfff2f93bfff2fff2; ++ *((unsigned long *)&__m256i_result1) = 0xfff2f7bcfff2f7bd; ++ *((unsigned long *)&__m256i_result0) = 0xfff2f93bfff2fff2; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_result2) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_result1) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_result0) = 0xfff9fff9fff9fff9; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_result2) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_result1) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m256i_result0) = 0xfff3fff3fff3fff3; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff2fff2fff2fff2; ++ *((unsigned long *)&__m256i_result2) = 0xfff2fff2fff2fff2; ++ *((unsigned long *)&__m256i_result1) = 0xfff2fff2fff2fff2; ++ *((unsigned long *)&__m256i_result0) = 0xfff2fff2fff2fff2; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_h (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op02) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op01) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op00) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result3) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000400000004; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff0e400; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fff0e400; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000100000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff2fffffff2; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff2fffffff2; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff2fffffff2; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff2fffffff2; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000010000000a; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff8fffffff8; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff8fffffff8; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff8fffffff8; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff8fffffff8; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff7fffffff7; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256i_result1) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff0fffffff0; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmini_w (__m256i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_d (__m256i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x327f010101010102; ++ *((unsigned long *)&__m256i_op02) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x327f010101010102; ++ *((unsigned long *)&__m256i_op00) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffff4; ++ __m256i_out = __lasx_xvmini_d (__m256i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000900000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000009; ++ __m256i_out = __lasx_xvmini_d (__m256i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_d (__m256i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvmini_d (__m256i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op02) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op00) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result2) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result0) = 0xff00ff007f007f00; ++ __m256i_out = __lasx_xvmini_d (__m256i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_d (__m256i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-2.c +new file mode 100644 +index 000000000..8eb7d9355 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmini-2.c +@@ -0,0 +1,284 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op02) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op01) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op00) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_result3) = 0x0d0d0d0d00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result1) = 0x0d0d0d0d00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0d0d0d0d0d0d0d0d; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x1b1b1b1b1b1b1b1b; ++ *((unsigned long *)&__m256i_result2) = 0x1b1b1b1b1b1b1b1b; ++ *((unsigned long *)&__m256i_result1) = 0x1b1b1b1b1b1b1b1b; ++ *((unsigned long *)&__m256i_result0) = 0x1b1b1b1b1b1b1b1b; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1e1e1e0000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1e1e1e0000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1e1e1e0000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1e1e1e0000000000; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op02) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_op01) = 0x6018000000000cd1; ++ *((unsigned long *)&__m256i_op00) = 0x6040190d00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_result2) = 0x0a0a0a0a00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0a0a000000000a0a; ++ *((unsigned long *)&__m256i_result0) = 0x0a0a0a0a00000000; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0008001c0010001c; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0008001c0010001c; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_bu (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_hu (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0007000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0007000000000000; ++ __m256i_out = __lasx_xvmini_hu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_op02) = 0x00003ddd80007bbb; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_op00) = 0x00003ddd80007bbb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result2) = 0x0000001700170017; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000017; ++ *((unsigned long *)&__m256i_result0) = 0x0000001700170017; ++ __m256i_out = __lasx_xvmini_hu (__m256i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_hu (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_hu (__m256i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op02) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op01) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op00) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffe400000707; ++ *((unsigned long *)&__m256i_op02) = 0x00000af100001455; ++ *((unsigned long *)&__m256i_op01) = 0xffffffe400000707; ++ *((unsigned long *)&__m256i_op00) = 0x00000af100001455; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff61010380; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff61010380; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000006; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmini_du (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvmul-xvmod-xvdiv.patch
Added
@@ -0,0 +1,5766 @@ +From 95ce2bef98ebcebebcdb3a9411d1c9783935ac89 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:23:35 +0800 +Subject: PATCH 102/124 LoongArch: Add tests for ASX vector xvmul/xvmod/xvdiv + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvdiv-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvdiv-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmod-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmod-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmul.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmulwev-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmulwev-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmulwev-3.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmulwod-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmulwod-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvmulwod-3.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvdiv-1.c | 485 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvdiv-2.c | 500 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmod-1.c | 395 +++++++++++ + .../loongarch/vector/lasx/lasx-xvmod-2.c | 410 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvmul.c | 620 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmulwev-1.c | 590 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmulwev-2.c | 590 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmulwev-3.c | 605 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmulwod-1.c | 545 +++++++++++++++ + .../loongarch/vector/lasx/lasx-xvmulwod-2.c | 470 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvmulwod-3.c | 440 +++++++++++++ + 11 files changed, 5650 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmul.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-3.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-1.c +new file mode 100644 +index 000000000..0d7c67703 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-1.c +@@ -0,0 +1,485 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00080000000cc916; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000006fff3; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00f8000000f41bfb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000fa0106; ++ __m256i_out = __lasx_xvdiv_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000fe000000fe; ++ *((unsigned long *)&__m256i_result2) = 0x000000fe000000fe; ++ *((unsigned long *)&__m256i_result1) = 0x000000fe000000fe; ++ *((unsigned long *)&__m256i_result0) = 0x000000fe000000fe; ++ __m256i_out = __lasx_xvdiv_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op12) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op11) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op10) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fe8001b72e0001; ++ *((unsigned long *)&__m256i_op02) = 0xb72e8001b72eaf12; ++ *((unsigned long *)&__m256i_op01) = 0x01fe000247639d9c; ++ *((unsigned long *)&__m256i_op00) = 0xb5308001b72eaf12; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_op11) = 0x017e00ff017e00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_result3) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_result2) = 0xffb7ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_result1) = 0x00010000002fff9e; ++ *((unsigned long *)&__m256i_result0) = 0xffb5ff80ffd0ffd8; ++ __m256i_out = __lasx_xvdiv_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8091811081118110; ++ *((unsigned long *)&__m256i_op02) = 0x80a6802680208015; ++ *((unsigned long *)&__m256i_op01) = 0x8091811081110013; ++ *((unsigned long *)&__m256i_op00) = 0x80a6802680200018; ++ *((unsigned long *)&__m256i_op13) = 0x8091811081118110; ++ *((unsigned long *)&__m256i_op12) = 0x80a6802680208015; ++ *((unsigned long *)&__m256i_op11) = 0x8091811081110013; ++ *((unsigned long *)&__m256i_op10) = 0x80a6802680200018; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvdiv_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x1f831f80e0e09f86; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x1f831f80e0e09f86; ++ __m256i_out = __lasx_xvdiv_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdededededededede; ++ *((unsigned long *)&__m256i_op12) = 0xdededededededede; ++ *((unsigned long *)&__m256i_op11) = 0xdededededededede; ++ *((unsigned long *)&__m256i_op10) = 0xdededededededede; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffa080000001; ++ *((unsigned long *)&__m256i_op12) = 0xffffffe080000001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffa080000001; ++ *((unsigned long *)&__m256i_op10) = 0xffffffe080000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_op12) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_op11) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_op10) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x0000fd00ffff02ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001fffeff; ++ *((unsigned long *)&__m256i_op00) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_op13) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0xffffff81ffffff00; ++ __m256i_out = __lasx_xvdiv_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffff00; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffff00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff0000000f; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff0000000d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvdiv_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op12) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op11) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op10) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000d000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000d000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000583800; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000100000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000583800; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000100000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d0000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffff30000000b; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m256i_op11) = 0xfffffff30000000b; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000007fef; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007fef; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000007fef; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007fef; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op12) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000008050501; ++ *((unsigned long *)&__m256i_op10) = 0x0100000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000003f; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op13) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffffe; ++ __m256i_out = __lasx_xvdiv_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-2.c +new file mode 100644 +index 000000000..fd8b6d38c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvdiv-2.c +@@ -0,0 +1,500 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000017e; ++ *((unsigned long *)&__m256i_op13) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_op12) = 0x0202810102020202; ++ *((unsigned long *)&__m256i_op11) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_op10) = 0x0202810102020202; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000003f; ++ __m256i_out = __lasx_xvdiv_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffba0c05; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffba0c05; ++ *((unsigned long *)&__m256i_op13) = 0x5353535353535353; ++ *((unsigned long *)&__m256i_op12) = 0x5353535353535353; ++ *((unsigned long *)&__m256i_op11) = 0x5353535353535353; ++ *((unsigned long *)&__m256i_op10) = 0x5353535353535353; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0303030303020000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0303030303020000; ++ __m256i_out = __lasx_xvdiv_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0100010001000100; ++ __m256i_out = __lasx_xvdiv_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000030b8; ++ *((unsigned long *)&__m256i_op13) = 0x9fe7fffffffff32e; ++ *((unsigned long *)&__m256i_op12) = 0x6040190ddfdd8587; ++ *((unsigned long *)&__m256i_op11) = 0xecd011542d2cc4c7; ++ *((unsigned long *)&__m256i_op10) = 0x6040190dffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op12) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op11) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op10) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result3) = 0x7f7fff7f7f7fff7f; ++ *((unsigned long *)&__m256i_result2) = 0x7f7fff7f7f7fff7f; ++ *((unsigned long *)&__m256i_result1) = 0x7f7fff7f7f7fff7f; ++ *((unsigned long *)&__m256i_result0) = 0x7f7fff7f7f7fff7f; ++ __m256i_out = __lasx_xvdiv_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001010000; ++ __m256i_out = __lasx_xvdiv_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000007fee; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_op02) = 0xe2e2e202ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_op00) = 0xe2e2e202ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffc6ffc6003a003a; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvdiv_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010202020203; ++ *((unsigned long *)&__m256i_op12) = 0x0101010201010102; ++ *((unsigned long *)&__m256i_op11) = 0x0101010202020203; ++ *((unsigned long *)&__m256i_op10) = 0x0101010201010102; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00020001ffb6ffe0; ++ *((unsigned long *)&__m256i_op00) = 0x0049004200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ff80; ++ *((unsigned long *)&__m256i_op12) = 0x0000468600007f79; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000f3280000dfff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffb7; ++ *((unsigned long *)&__m256i_result0) = 0x0000004c00000000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op13) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op12) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op11) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op10) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000003fb000003fb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000003fb000003fb; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1fe01e0100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x1fe01e0100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x1fe01e0100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x1fe01e0100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff827f80; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0226823c; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff827f80; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0226823c; ++ *((unsigned long *)&__m256i_op13) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x007d003e007d003e; ++ *((unsigned long *)&__m256i_op12) = 0x007d003effa80010; ++ *((unsigned long *)&__m256i_op11) = 0x007d003e007d003e; ++ *((unsigned long *)&__m256i_op10) = 0x007d003effa80010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_op12) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_op11) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_op10) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op12) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_op11) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op10) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000008000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000008000000100; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000008000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9cffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x9cffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000045; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000d0005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000013b13380; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000013b13380; ++ __m256i_out = __lasx_xvdiv_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000e2e20000e2e2; ++ *((unsigned long *)&__m256i_op02) = 0x00011d1c00011d9c; ++ *((unsigned long *)&__m256i_op01) = 0x0000e2e20000e2e2; ++ *((unsigned long *)&__m256i_op00) = 0x00011d1c00011d9c; ++ *((unsigned long *)&__m256i_op13) = 0x0000e2e20000e2e2; ++ *((unsigned long *)&__m256i_op12) = 0x00011d1c00011d9c; ++ *((unsigned long *)&__m256i_op11) = 0x0000e2e20000e2e2; ++ *((unsigned long *)&__m256i_op10) = 0x00011d1c00011d9c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvdiv_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_op12) = 0x1b1a191817161514; ++ *((unsigned long *)&__m256i_op11) = 0x232221201f1e1d1c; ++ *((unsigned long *)&__m256i_op10) = 0x1b1a191817161514; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000101; ++ __m256i_out = __lasx_xvdiv_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010202020203; ++ *((unsigned long *)&__m256i_op02) = 0x0101010201010102; ++ *((unsigned long *)&__m256i_op01) = 0x0101010202020203; ++ *((unsigned long *)&__m256i_op00) = 0x0101010201010102; ++ *((unsigned long *)&__m256i_op13) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256i_op11) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff0fffffff0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvdiv_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-1.c +new file mode 100644 +index 000000000..6f34f6ffc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-1.c +@@ -0,0 +1,395 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000000000; ++ __m256i_out = __lasx_xvmod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op12) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op11) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_op10) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8001b72e0001b72e; ++ *((unsigned long *)&__m256i_op02) = 0x8001b72eaf12d5f0; ++ *((unsigned long *)&__m256i_op01) = 0x000247639d9cb530; ++ *((unsigned long *)&__m256i_op00) = 0x8001b72eaf12d5f0; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_op11) = 0x017e00ff017e00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_result3) = 0xff81ffe50001ffe5; ++ *((unsigned long *)&__m256i_result2) = 0xff81ffe5ffa6ffc6; ++ *((unsigned long *)&__m256i_result1) = 0x000200aafe9affe5; ++ *((unsigned long *)&__m256i_result0) = 0xff81ffe5ffa6ffc6; ++ __m256i_out = __lasx_xvmod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op12) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op11) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op10) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x80008000b70fb810; ++ *((unsigned long *)&__m256i_op02) = 0x3c0f3c0f3911b910; ++ *((unsigned long *)&__m256i_op01) = 0x80008000b70fb810; ++ *((unsigned long *)&__m256i_op00) = 0x3c0f3c0f3911b910; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff6f20; ++ *((unsigned long *)&__m256i_result2) = 0x0000781e0000f221; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff6f20; ++ *((unsigned long *)&__m256i_result0) = 0x0000781e0000f221; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_op12) = 0x8800c800c800c801; ++ *((unsigned long *)&__m256i_op11) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_op10) = 0x8800c800c800c801; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_op02) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_op01) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_op00) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_op13) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op12) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_op11) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op10) = 0x7fe363637fe36363; ++ *((unsigned long *)&__m256i_result3) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_result2) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_result1) = 0x0101000101010001; ++ *((unsigned long *)&__m256i_result0) = 0x0101000101010001; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op12) = 0xc3030000ff800000; ++ *((unsigned long *)&__m256i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op10) = 0xc3030000ff800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_op11) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000010100; ++ *((unsigned long *)&__m256i_op00) = 0x0001000001000100; ++ *((unsigned long *)&__m256i_op13) = 0x8000800000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000800080000000; ++ *((unsigned long *)&__m256i_op11) = 0xc9d8080067f50020; ++ *((unsigned long *)&__m256i_op10) = 0xc70000020000c000; ++ *((unsigned long *)&__m256i_result3) = 0x0001010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000010100; ++ *((unsigned long *)&__m256i_result0) = 0x0001000001000100; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_op12) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_op11) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_op10) = 0xff3cff3cff3cff3c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op12) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op11) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op10) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_op12) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_op11) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_op10) = 0x0000001400000014; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op02) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op01) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op00) = 0x7c007c007c007c00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007efeff00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007efeff00; ++ *((unsigned long *)&__m256i_result3) = 0x00000000008e7c00; ++ *((unsigned long *)&__m256i_result2) = 0x0000000067751500; ++ *((unsigned long *)&__m256i_result1) = 0x00000000008e7c00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000067751500; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_op01) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_op13) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_op12) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op11) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_op10) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result3) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_result1) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffefffefffefffef; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op12) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op11) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_op10) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op02) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_op01) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op00) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_op13) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op12) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_op11) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op10) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000e0001000e; ++ *((unsigned long *)&__m256i_op12) = 0x0001000e0001000e; ++ *((unsigned long *)&__m256i_op11) = 0x0001000e0001000e; ++ *((unsigned long *)&__m256i_op10) = 0x0001000e0001000e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-2.c +new file mode 100644 +index 000000000..d0a9e9d2f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmod-2.c +@@ -0,0 +1,410 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1e18000000000000; ++ __m256i_out = __lasx_xvmod_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_op12) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_op11) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_op10) = 0x0909090909090909; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op12) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op11) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op10) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x01010101010101c9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvmod_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op12) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op11) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op10) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffe000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffe000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000e000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000e000; ++ __m256i_out = __lasx_xvmod_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op02) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op01) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op00) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op13) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op12) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op11) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op10) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe06df8d7; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffbe8b470f; ++ *((unsigned long *)&__m256i_op13) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffe06df0d7; ++ *((unsigned long *)&__m256i_op11) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffbe8b470f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op02) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op01) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op00) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op13) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op12) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_op11) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op10) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_result3) = 0x081abb9d36ee1037; ++ *((unsigned long *)&__m256i_result2) = 0x1617eb17129bfd38; ++ *((unsigned long *)&__m256i_result1) = 0x081abb9d36ee1037; ++ *((unsigned long *)&__m256i_result0) = 0x1617eb17129bfd38; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op12) = 0xfe8bfe0efe8bfe12; ++ *((unsigned long *)&__m256i_op11) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op10) = 0xfe8bfe0efe8bfe12; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_op12) = 0x8e8e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_op11) = 0x7171717171717171; ++ *((unsigned long *)&__m256i_op10) = 0x8e8e8e8e8e8e8e8e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000005500000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001005500020000; ++ *((unsigned long *)&__m256i_op01) = 0x0000005500000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001005500020000; ++ *((unsigned long *)&__m256i_op13) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op12) = 0x000100010001fffe; ++ *((unsigned long *)&__m256i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x000100010001fffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000005500000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000005400000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000005500000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000005400000002; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_op12) = 0x007f0000ff807f81; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_op10) = 0x007f0000ff807f81; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff0000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff8000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_op12) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_op11) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_op10) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffff000000010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000095120000; ++ *((unsigned long *)&__m256i_op11) = 0xc9da000063f50000; ++ *((unsigned long *)&__m256i_op10) = 0xc7387fff6bbfffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvmod_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op13) = 0x1fffffff1fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0383634303836343; ++ *((unsigned long *)&__m256i_op11) = 0x1fffffff1fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0383634303836343; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001000000; ++ __m256i_out = __lasx_xvmod_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256i_op12) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256i_op11) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256i_op10) = 0x00007f8000007f80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmod_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmul.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmul.c +new file mode 100644 +index 000000000..be3c8e718 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmul.c +@@ -0,0 +1,620 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffd1b24e00000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffcea54ffff29a8; ++ *((unsigned long *)&__m256i_op01) = 0xff8cad88ff8306b4; ++ *((unsigned long *)&__m256i_op00) = 0xfffc1278fffce4c8; ++ *((unsigned long *)&__m256i_op13) = 0x0e2d5626ff75cdbc; ++ *((unsigned long *)&__m256i_op12) = 0x5db4b156e2002a78; ++ *((unsigned long *)&__m256i_op11) = 0xeeffbeb03ba3e6b0; ++ *((unsigned long *)&__m256i_op10) = 0x0c16e25eb28d27ea; ++ *((unsigned long *)&__m256i_result3) = 0xf96d674800000000; ++ *((unsigned long *)&__m256i_result2) = 0x44a4330e2c7116c0; ++ *((unsigned long *)&__m256i_result1) = 0x14187a7822b653c0; ++ *((unsigned long *)&__m256i_result0) = 0xfbe0b866962b96d0; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffff01ffffff08; ++ *((unsigned long *)&__m256i_op12) = 0x43700f0100003008; ++ *((unsigned long *)&__m256i_op11) = 0xffffff01ffffff08; ++ *((unsigned long *)&__m256i_op10) = 0x43700f0100003008; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000f8; ++ *((unsigned long *)&__m256i_result2) = 0xbc8ff0ffffffcff8; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000f8; ++ *((unsigned long *)&__m256i_result0) = 0xbc8ff0ffffffcff8; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x353bb67af686ad9b; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x353bb67af686ad9b; ++ *((unsigned long *)&__m256i_op13) = 0x0200000200000000; ++ *((unsigned long *)&__m256i_op12) = 0x2c27000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0200000200000000; ++ *((unsigned long *)&__m256i_op10) = 0x2c27000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1cfd000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000180000000; ++ *((unsigned long *)&__m256i_op13) = 0xc080ffff0049ffd2; ++ *((unsigned long *)&__m256i_op12) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_op11) = 0x0000fffeffb9ff9d; ++ *((unsigned long *)&__m256i_op10) = 0x00010000002fff9e; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffd2; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff8000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000080000000; ++ __m256i_out = __lasx_xvmul_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op01) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op02) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op01) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op00) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fff003f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fff003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000627; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000627; ++ __m256i_out = __lasx_xvmul_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffd5a98; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffd5a98; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007f3a40; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000400; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000400; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x120e120dedf1edf2; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x120e120dedf1edf2; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op12) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op11) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op10) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result3) = 0x1010000010100000; ++ *((unsigned long *)&__m256i_result2) = 0x1010000010100000; ++ *((unsigned long *)&__m256i_result1) = 0x1010000010100000; ++ *((unsigned long *)&__m256i_result0) = 0x1010000010100000; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x00007fff00000001; ++ *((unsigned long *)&__m256i_op01) = 0x0040000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x00007fff00000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op02) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op01) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op00) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffefffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op12) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op11) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_result2) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_result1) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op12) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_op11) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op10) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffff30000000b; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m256i_op01) = 0xfffffff30000000b; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m256i_op13) = 0xbc30c40108a45423; ++ *((unsigned long *)&__m256i_op12) = 0xbc263e0e5d00e69f; ++ *((unsigned long *)&__m256i_op11) = 0xbc30c40108a4544b; ++ *((unsigned long *)&__m256i_op10) = 0xbc20e63aa8b9663f; ++ *((unsigned long *)&__m256i_result3) = 0x71860bf35f0f9d81; ++ *((unsigned long *)&__m256i_result2) = 0x720ed94a46f449ed; ++ *((unsigned long *)&__m256i_result1) = 0x71860bf35f0f9f39; ++ *((unsigned long *)&__m256i_result0) = 0x72544f0e6e95cecd; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x111ebb784f9c4100; ++ *((unsigned long *)&__m256i_op02) = 0x1c386546809f3b50; ++ *((unsigned long *)&__m256i_op01) = 0x111ebb784f9bf1ac; ++ *((unsigned long *)&__m256i_op00) = 0x21f6050d955d3f68; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xbab0c4b000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xaa0ac09800000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8011ffee804c004c; ++ *((unsigned long *)&__m256i_op02) = 0x00faff0500c3ff3c; ++ *((unsigned long *)&__m256i_op01) = 0x80f900f980780078; ++ *((unsigned long *)&__m256i_op00) = 0x0057ffa800ceff31; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00bf00bf00bf00bf; ++ *((unsigned long *)&__m256i_op02) = 0x00bf00bf00bf00bf; ++ *((unsigned long *)&__m256i_op01) = 0x00bf00bf00bf00bf; ++ *((unsigned long *)&__m256i_op00) = 0x00bf00bf00bf00bf; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000011; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000088; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000088; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xc0008000c0008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xc0008000c0008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_op01) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_op02) = 0xffffdf5b000041b0; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffeffff97a1; ++ *((unsigned long *)&__m256i_op00) = 0xffffdf5b000041b0; ++ *((unsigned long *)&__m256i_op13) = 0x00f8000000000008; ++ *((unsigned long *)&__m256i_op12) = 0x000800f800000000; ++ *((unsigned long *)&__m256i_op11) = 0x00f8000000000008; ++ *((unsigned long *)&__m256i_op10) = 0x000800f800000000; ++ *((unsigned long *)&__m256i_result3) = 0xe3f7fff7fffcbd08; ++ *((unsigned long *)&__m256i_result2) = 0x0dbfa28000000000; ++ *((unsigned long *)&__m256i_result1) = 0xe3f7fff7fffcbd08; ++ *((unsigned long *)&__m256i_result0) = 0x0dbfa28000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op02) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op01) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op00) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x7070545438381c1c; ++ *((unsigned long *)&__m256i_result2) = 0x7070545438381c1c; ++ *((unsigned long *)&__m256i_result1) = 0x7070545438381c1c; ++ *((unsigned long *)&__m256i_result0) = 0x7070545438381c1c; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_op12) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_op11) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_op10) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmul_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-1.c +new file mode 100644 +index 000000000..01ff71649 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-1.c +@@ -0,0 +1,590 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xf96d674800000000; ++ *((unsigned long *)&__m256i_op02) = 0x44a4330e2c7116c0; ++ *((unsigned long *)&__m256i_op01) = 0x14187a7822b653c0; ++ *((unsigned long *)&__m256i_op00) = 0xfbe0b866962b96d0; ++ *((unsigned long *)&__m256i_op13) = 0xffd1b24e00000000; ++ *((unsigned long *)&__m256i_op12) = 0xfffcea54ffff29a8; ++ *((unsigned long *)&__m256i_op11) = 0xff8cad88ff8306b4; ++ *((unsigned long *)&__m256i_op10) = 0xfffc1278fffce4c8; ++ *((unsigned long *)&__m256i_result3) = 0xebfd15f000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01700498ff8f1600; ++ *((unsigned long *)&__m256i_result1) = 0xf520c7c024221300; ++ *((unsigned long *)&__m256i_result0) = 0x00802fd0ff540a80; ++ __m256i_out = __lasx_xvmulwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffff90ffffff81; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffff90ffffff81; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffbdff3cffbdff44; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000001dc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000001dc; ++ __m256i_out = __lasx_xvmulwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op02) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op01) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op00) = 0xff00ff00ff00ef32; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff00ff00ee; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00ff00ee; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffce; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000fc7c; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffce; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000fc7c; ++ __m256i_out = __lasx_xvmulwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf800f800f800c000; ++ *((unsigned long *)&__m256i_op02) = 0xf800f800f800a000; ++ *((unsigned long *)&__m256i_op01) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_op00) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_op13) = 0xffff00ffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff8080000004000; ++ *((unsigned long *)&__m256i_result2) = 0x0000080000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff8080000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00001ff800000000; ++ *((unsigned long *)&__m256i_op12) = 0xd8d8c00000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00001ff800000000; ++ *((unsigned long *)&__m256i_op10) = 0xd8d8c00000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x3f80000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x3f80000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op02) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op01) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op00) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op13) = 0xfffffff8ffffff08; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00f800ffcff8; ++ *((unsigned long *)&__m256i_op11) = 0xfffffff8ffffff08; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00f800ffcff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000003868686a20; ++ *((unsigned long *)&__m256i_result2) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_result1) = 0x0000003868686a20; ++ *((unsigned long *)&__m256i_result0) = 0x0045b8ae81bce1d8; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x6c6c6c6c6c6c6c6c; ++ *((unsigned long *)&__m256i_op12) = 0x6c6c6c6c6c6c6c6c; ++ *((unsigned long *)&__m256i_op11) = 0x6c6c6c6c6c6c6c6c; ++ *((unsigned long *)&__m256i_op10) = 0x6c6c6c6c6c6c6c6c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00ffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op12) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op11) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_op10) = 0xfd12fd12fd12fd12; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000060000108; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001060005; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fef0001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x201fdfe0201fdfe0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x201fdfe0201fdfe0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_op11) = 0x000000017bfffff0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000180007fe8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000fd; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000062d4; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-2.c +new file mode 100644 +index 000000000..32088f4ae +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-2.c +@@ -0,0 +1,590 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x4e5cba76cdbaaa78; ++ *((unsigned long *)&__m256i_op02) = 0xce68fdeb4e33eaff; ++ *((unsigned long *)&__m256i_op01) = 0x4e45cc2dcda41b30; ++ *((unsigned long *)&__m256i_op00) = 0x4ccb1e5c4d6b21e4; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x44bb2cd3a35c2fd0; ++ *((unsigned long *)&__m256i_result0) = 0xca355ba46a95e31c; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202000002020202; ++ *((unsigned long *)&__m256i_op02) = 0x0202000002010101; ++ *((unsigned long *)&__m256i_op01) = 0x0202000002020202; ++ *((unsigned long *)&__m256i_op00) = 0x0202000002020000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01fe000000ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01fe000001fe0000; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000f788f788; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000f788f788; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff01ff68; ++ *((unsigned long *)&__m256i_op02) = 0x00000070ff017de6; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff01ff68; ++ *((unsigned long *)&__m256i_op00) = 0x00000070ff017de6; ++ *((unsigned long *)&__m256i_op13) = 0x761ed60b5d7f0000; ++ *((unsigned long *)&__m256i_op12) = 0xdc9938afafe904f1; ++ *((unsigned long *)&__m256i_op11) = 0x761ed60b5d7f0000; ++ *((unsigned long *)&__m256i_op10) = 0xdc9938afafe904f1; ++ *((unsigned long *)&__m256i_result3) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_result2) = 0x00004c9000e9d886; ++ *((unsigned long *)&__m256i_result1) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_result0) = 0x00004c9000e9d886; ++ __m256i_out = __lasx_xvmulwev_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffff328dfff; ++ *((unsigned long *)&__m256i_op00) = 0x6651bfff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffff328dfff; ++ *((unsigned long *)&__m256i_op10) = 0x6651bfff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffe0001c3fe4001; ++ *((unsigned long *)&__m256i_result0) = 0x8ffe800100000000; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff01ff010000fff9; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff19; ++ *((unsigned long *)&__m256i_op01) = 0xff02ff020001fffa; ++ *((unsigned long *)&__m256i_op00) = 0x000100010001fffa; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x00fe01ff0006ffcf; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000e62f8f; ++ *((unsigned long *)&__m256i_result1) = 0x00fe02fe0006ffd6; ++ *((unsigned long *)&__m256i_result0) = 0x000000000006ffd6; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x01010101010000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result3) = 0x0100feff0100eeef; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000001010; ++ *((unsigned long *)&__m256i_result1) = 0x0100feff00feef11; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000001010; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x201fdfe0201fdfe0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x201fdfe0201fdfe0; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff47b4ffff5878; ++ *((unsigned long *)&__m256i_op12) = 0x0000b84b0000a787; ++ *((unsigned long *)&__m256i_op11) = 0xffff47b4ffff5878; ++ *((unsigned long *)&__m256i_op10) = 0x0000b84b0000a787; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000010100000101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000010100000101; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff1b00e4; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op12) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_op10) = 0x0808080808080808; ++ *((unsigned long *)&__m256i_result3) = 0x0807f7f80807f7f8; ++ *((unsigned long *)&__m256i_result2) = 0x0807f7f80807f7f8; ++ *((unsigned long *)&__m256i_result1) = 0x0807f7f80807f7f8; ++ *((unsigned long *)&__m256i_result0) = 0x0807f7f80807f7f8; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op02) = 0xc2c2c2c2c2c29cc0; ++ *((unsigned long *)&__m256i_op01) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op00) = 0xc2c2c2c2c2c29cc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000004e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000001; ++ __m256i_out = __lasx_xvmulwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000000a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000a; ++ __m256i_out = __lasx_xvmulwev_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000007f000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0408040800008003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0408040800008003; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0408040800008002; ++ *((unsigned long *)&__m256i_result0) = 0xfbf7fbf7ffff7ffd; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000009; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xc192181230000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xc192181230000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op13) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0x04080c1014182d35; ++ *((unsigned long *)&__m256i_result2) = 0x716d696573765161; ++ *((unsigned long *)&__m256i_result1) = 0x04080c1014182d35; ++ *((unsigned long *)&__m256i_result0) = 0x716d696573765161; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op11) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-3.c +new file mode 100644 +index 000000000..19157f682 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwev-3.c +@@ -0,0 +1,605 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffefe; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffefe; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01fe02; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff01ff01fe02; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000ff; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000505; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000004fb; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fff0e400; ++ *((unsigned long *)&__m256i_op13) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x80000000ffff8c80; ++ *((unsigned long *)&__m256i_op11) = 0x80000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x80000000fff0e400; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff01c000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff01ff01; ++ *((unsigned long *)&__m256i_result0) = 0x00000000f1000000; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01fe04; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff01ff01fe04; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000022ffdd; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000022ffdd; ++ *((unsigned long *)&__m256i_op13) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000f4b6ff23; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000f4b6ff23; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fffe00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fffe00000000; ++ *((unsigned long *)&__m256i_op13) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x386000003df80000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x5fa0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x5fa0000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000f20; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000009f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op13) = 0x417e01f040800000; ++ *((unsigned long *)&__m256i_op12) = 0x299d060000000000; ++ *((unsigned long *)&__m256i_op11) = 0x417e01f040800000; ++ *((unsigned long *)&__m256i_op10) = 0x29108b0000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op13) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op12) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_op11) = 0x0707feb60707b7d0; ++ *((unsigned long *)&__m256i_op10) = 0x45baa7ef6a95a985; ++ *((unsigned long *)&__m256i_result3) = 0x0707b7cff8f84830; ++ *((unsigned long *)&__m256i_result2) = 0x0000000354ad4c28; ++ *((unsigned long *)&__m256i_result1) = 0x0707b7cff8f84830; ++ *((unsigned long *)&__m256i_result0) = 0x0000000354ad4c28; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00d5007f00ffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op01) = 0xff00d5007f00ffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op02) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op00) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_op12) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_op11) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_op10) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ef; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000016e00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000155b200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000b70000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001ff03fe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffec75c2d209f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001ff03fe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffec75c2d209f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000008b; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffff010000008b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op02) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op00) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op13) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op12) = 0x03acfc5303260e80; ++ *((unsigned long *)&__m256i_op11) = 0x03af03af03af03af; ++ *((unsigned long *)&__m256i_op10) = 0x03acfc5303260e80; ++ *((unsigned long *)&__m256i_result3) = 0x00000b0cfffff4f3; ++ *((unsigned long *)&__m256i_result2) = 0x000f9bb562f56c80; ++ *((unsigned long *)&__m256i_result1) = 0x00000b0cfffff4f3; ++ *((unsigned long *)&__m256i_result0) = 0x000f9bb562f56c80; ++ __m256i_out = __lasx_xvmulwev_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x3ff1808001020101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x3ff1808001020101; ++ *((unsigned long *)&__m256i_op13) = 0x00000ff7f1080ef8; ++ *((unsigned long *)&__m256i_op12) = 0x0100000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000ff7f1080ef8; ++ *((unsigned long *)&__m256i_op10) = 0x0100000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x003ff18080010201; ++ *((unsigned long *)&__m256i_result2) = 0x0100000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x003ff18080010201; ++ *((unsigned long *)&__m256i_result0) = 0x0100000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op02) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfbba01c0003f7e3f; ++ *((unsigned long *)&__m256i_op12) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_op11) = 0xfbd884e7003f7e3f; ++ *((unsigned long *)&__m256i_op10) = 0xff874dc687870000; ++ *((unsigned long *)&__m256i_result3) = 0xffe367cc82f8989a; ++ *((unsigned long *)&__m256i_result2) = 0x4f90000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffc3aaa8d58f43c8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op12) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op11) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op10) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffdfffffffdfffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffdfffffffdfffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0020000000200001; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0020000000200001; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000aaabffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffff000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff01; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffff2; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff01; ++ *((unsigned long *)&__m256i_op13) = 0x1010101010001000; ++ *((unsigned long *)&__m256i_op12) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op11) = 0x101010100000000e; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000fe; ++ *((unsigned long *)&__m256i_result2) = 0xffff01feffff01ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000fe; ++ *((unsigned long *)&__m256i_result0) = 0xffff01feffff01ff; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff02000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff02000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x5fa0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x5fa0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwev_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-1.c +new file mode 100644 +index 000000000..80fdcda63 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-1.c +@@ -0,0 +1,545 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x7a7cad6eca32ccc1; ++ *((unsigned long *)&__m256i_op12) = 0x7a7cad6efe69abd1; ++ *((unsigned long *)&__m256i_op11) = 0x7a7cad6eca32ccc1; ++ *((unsigned long *)&__m256i_op10) = 0x7a7cad6efe69abd1; ++ *((unsigned long *)&__m256i_result3) = 0xff86005300360034; ++ *((unsigned long *)&__m256i_result2) = 0xff86005300020055; ++ *((unsigned long *)&__m256i_result1) = 0xff86005300360034; ++ *((unsigned long *)&__m256i_result0) = 0xff86005300020055; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x2c27000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x2c27000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op02) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op01) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op00) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000007f3a40; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000007f3a40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000d24; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op12) = 0x0000000073333333; ++ *((unsigned long *)&__m256i_op11) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op10) = 0x0000000073333333; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff0020001d001f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fffe00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fffe00000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ca0000fff80000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00ca0000fff80000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010080; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000015d050192cb; ++ *((unsigned long *)&__m256i_op02) = 0x028e509508b16ee9; ++ *((unsigned long *)&__m256i_op01) = 0x000033ff01020e23; ++ *((unsigned long *)&__m256i_op00) = 0x151196b58fd1114d; ++ *((unsigned long *)&__m256i_op13) = 0x00ff0000ffff00ff; ++ *((unsigned long *)&__m256i_op12) = 0xff000000ffffff00; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffffffff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fffffaff; ++ *((unsigned long *)&__m256i_result2) = 0xfffd7200fffff74f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000702f; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000808; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0408040800008003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x04080408fff87803; ++ *((unsigned long *)&__m256i_op13) = 0x0707b7cff8f84830; ++ *((unsigned long *)&__m256i_op12) = 0x0000000354ad4c28; ++ *((unsigned long *)&__m256i_op11) = 0x0707b7cff8f84830; ++ *((unsigned long *)&__m256i_op10) = 0x0000000354ad4c28; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffd5a98; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000007e8080; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007e8092; ++ *((unsigned long *)&__m256i_op01) = 0x00000000007e8080; ++ *((unsigned long *)&__m256i_op00) = 0x00000000007e8092; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe07de080; ++ *((unsigned long *)&__m256i_op02) = 0x000000001f20607a; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe07de080; ++ *((unsigned long *)&__m256i_op00) = 0x000000001f20607a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000f6ff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op02) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op01) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op00) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op13) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op12) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op11) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_op10) = 0x0010000000100000; ++ *((unsigned long *)&__m256i_result3) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00153f1594ea02ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffff0100; ++ *((unsigned long *)&__m256i_op00) = 0xff15c1ea95ea02ff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_op11) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfe7ffffffeffffc0; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfe7ffffffeffffc0; ++ __m256i_out = __lasx_xvmulwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmulwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000017fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000017fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-2.c +new file mode 100644 +index 000000000..1a4b221fe +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-2.c +@@ -0,0 +1,470 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x01480000052801a2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffdcff64; ++ *((unsigned long *)&__m256i_op13) = 0xbea2e127c046721f; ++ *((unsigned long *)&__m256i_op12) = 0x1729c073816edebe; ++ *((unsigned long *)&__m256i_op11) = 0xde91f010000006f9; ++ *((unsigned long *)&__m256i_op10) = 0x5ef1f90efefaf30d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00170000028500de; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fd02f20d; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffffa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op02) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m256i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op00) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4ffc3f7800000000; ++ *((unsigned long *)&__m256i_op02) = 0x3fc03f6400000000; ++ *((unsigned long *)&__m256i_op01) = 0x4ffc3f7800000000; ++ *((unsigned long *)&__m256i_op00) = 0x3fc03f6400000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x4eb13ec100000000; ++ *((unsigned long *)&__m256i_result2) = 0x3ec13ec100000000; ++ *((unsigned long *)&__m256i_result1) = 0x4eb13ec100000000; ++ *((unsigned long *)&__m256i_result0) = 0x3ec13ec100000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op02) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op01) = 0x457db03e457db03e; ++ *((unsigned long *)&__m256i_op00) = 0x457db03e45a87310; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfe01fe01fd02fd02; ++ *((unsigned long *)&__m256i_result2) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_result1) = 0xfe01fe01fd02fd02; ++ *((unsigned long *)&__m256i_result0) = 0x000000003fc03fc0; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op02) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op01) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op00) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_op13) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xc039000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x05ea05ea05ea05ec; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x05ea05ea05ea05ec; ++ *((unsigned long *)&__m256i_op13) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op12) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op11) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op10) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x04f104f104f104f1; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x04f104f104f104f1; ++ __m256i_out = __lasx_xvmulwod_h_bu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op12) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op11) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_op10) = 0x9090909090909090; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_w_hu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0ff8010000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0ff8010000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256i_op12) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffff8d9ffa7103d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020206431; ++ *((unsigned long *)&__m256i_op13) = 0x00f800f800f800f8; ++ *((unsigned long *)&__m256i_op12) = 0x0018181800181818; ++ *((unsigned long *)&__m256i_op11) = 0x00f800f800f800f8; ++ *((unsigned long *)&__m256i_op10) = 0x0018181800181818; ++ *((unsigned long *)&__m256i_result3) = 0x001f1f3e3e1f1f00; ++ *((unsigned long *)&__m256i_result2) = 0x0003060909060300; ++ *((unsigned long *)&__m256i_result1) = 0x001f1f3e3e1f1f00; ++ *((unsigned long *)&__m256i_result0) = 0x0003060909060300; ++ __m256i_out = __lasx_xvmulwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x800000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x800000ff000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0fffffff0fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x90007fff90008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0ffffffe90008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x4800408ef07f7f01; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0800000eeffffe02; ++ __m256i_out = __lasx_xvmulwod_d_wu (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvmulwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fc03e000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x01fc03e000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00fffb0402fddf20; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00fffb0402fddf20; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0001fbf9fbe29f52; ++ *((unsigned long *)&__m256i_result2) = 0x5b409c0000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001fbf9fbe29f52; ++ *((unsigned long *)&__m256i_result0) = 0x5b409c0000000000; ++ __m256i_out = __lasx_xvmulwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000c0000005; ++ *((unsigned long *)&__m256i_op02) = 0x21f8c3c4c0000005; ++ *((unsigned long *)&__m256i_op01) = 0x00000000c0000005; ++ *((unsigned long *)&__m256i_op00) = 0x21f8c3c4c0000005; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256i_op12) = 0x000043efffff8000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff8000; ++ *((unsigned long *)&__m256i_op10) = 0x000043efffff8000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xbfffa004fffd8000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xbfffa004fffd8000; ++ __m256i_out = __lasx_xvmulwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op02) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op00) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op02) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff6361; ++ *((unsigned long *)&__m256i_op00) = 0x4d0a902890b800dc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000203ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001ff03ff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000203ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001ff03fe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffec75c2d209f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001ff03fe; ++ *((unsigned long *)&__m256i_result0) = 0xfffffec75c2d209f; ++ __m256i_out = __lasx_xvmulwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0002fffc; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000fffd0003; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0002fffc; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000fffd0003; ++ __m256i_out = __lasx_xvmulwod_q_du (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-3.c +new file mode 100644 +index 000000000..9fcd3ce0c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvmulwod-3.c +@@ -0,0 +1,440 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x3f2c678e38d1104c; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00aa000000ac00fe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00aa000000ac00fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf01010153a10101; ++ *((unsigned long *)&__m256i_op02) = 0x5b7f01ff5b7f10ff; ++ *((unsigned long *)&__m256i_op01) = 0xdf01010153a10101; ++ *((unsigned long *)&__m256i_op00) = 0x5b7f01ff5b7f10ff; ++ *((unsigned long *)&__m256i_op13) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op12) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op11) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_op10) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffd8ffc7ffdaff8a; ++ *((unsigned long *)&__m256i_result3) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_h_bu_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_op10) = 0x00007fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00007ffe81fdfe03; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_d_wu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000017f00007f7f; ++ *((unsigned long *)&__m256i_op01) = 0x00007f0000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000fd; ++ *((unsigned long *)&__m256i_result0) = 0xffff810000000000; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x71860bf35f0f9d81; ++ *((unsigned long *)&__m256i_op02) = 0x720ed94a46f449ed; ++ *((unsigned long *)&__m256i_op01) = 0x71860bf35f0f9f39; ++ *((unsigned long *)&__m256i_op00) = 0x72544f0e6e95cecd; ++ *((unsigned long *)&__m256i_op13) = 0xffff8910ffff7e01; ++ *((unsigned long *)&__m256i_op12) = 0xffff3573ffff8960; ++ *((unsigned long *)&__m256i_op11) = 0xffff8910ffff1ca9; ++ *((unsigned long *)&__m256i_op10) = 0xfffff5e5ffff8130; ++ *((unsigned long *)&__m256i_result3) = 0xffffcb423a587053; ++ *((unsigned long *)&__m256i_result2) = 0x6d46f43e71141b81; ++ *((unsigned long *)&__m256i_result1) = 0xffffcb423a584528; ++ *((unsigned long *)&__m256i_result0) = 0x9bdf36c8d78158a1; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op13) = 0x800000007fff0001; ++ *((unsigned long *)&__m256i_op12) = 0x80000000ff7f0001; ++ *((unsigned long *)&__m256i_op11) = 0x800000007fff0001; ++ *((unsigned long *)&__m256i_op10) = 0x80000000ff7f0001; ++ *((unsigned long *)&__m256i_result3) = 0xbfffffffffff8000; ++ *((unsigned long *)&__m256i_result2) = 0xbfff800080000000; ++ *((unsigned long *)&__m256i_result1) = 0xbfffffffffff8000; ++ *((unsigned long *)&__m256i_result0) = 0xbfff800080000000; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000007f8; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000002de; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000007f8; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000002de; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000007f7; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffff808; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000007f7; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffff808; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op12) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op11) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op10) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvmulwod_q_du_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvpackev-xvpackod.patch
Added
@@ -0,0 +1,5364 @@ +From 9789698300a07a107bf78cd1c7fb9cf8fbddfca1 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 17:07:28 +0800 +Subject: PATCH 119/124 LoongArch: Add tests for ASX vector + xvpackev/xvpackod/xvpickev/xvpickod/ + xvpickve2gr/xvreplgr2vr/xvreplve/xvreplve0/xvreplvei/xvshuf4i/xvshuf + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvpackev.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvpackod.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvpickev.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvpickod.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvpickve.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvpickve2gr.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvreplgr2vr.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvreplve.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvreplve0.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvreplvei.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvshuf4i_b.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvshuf_b.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvpackev.c | 501 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvpackod.c | 575 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvpickev.c | 515 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvpickod.c | 530 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvpickve.c | 130 +++ + .../loongarch/vector/lasx/lasx-xvpickve2gr.c | 388 +++++++++ + .../loongarch/vector/lasx/lasx-xvreplgr2vr.c | 380 +++++++++ + .../loongarch/vector/lasx/lasx-xvreplve.c | 536 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvreplve0.c | 471 +++++++++++ + .../loongarch/vector/lasx/lasx-xvreplvei.c | 20 + + .../loongarch/vector/lasx/lasx-xvshuf4i_b.c | 430 ++++++++++ + .../loongarch/vector/lasx/lasx-xvshuf_b.c | 761 ++++++++++++++++++ + 12 files changed, 5237 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackev.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackod.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickev.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickod.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve2gr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplgr2vr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve0.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplvei.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf4i_b.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf_b.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackev.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackev.c +new file mode 100644 +index 000000000..33b96d657 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackev.c +@@ -0,0 +1,501 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x81f7f2599f0509c2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x51136d3c78388916; ++ *((unsigned long *)&__m256i_op13) = 0x044819410d87e69a; ++ *((unsigned long *)&__m256i_op12) = 0x21d3905ae3e93be0; ++ *((unsigned long *)&__m256i_op11) = 0x5125883a30da0f20; ++ *((unsigned long *)&__m256i_op10) = 0x6d7b2d3ac2777aeb; ++ *((unsigned long *)&__m256i_result3) = 0x000019410000e69a; ++ *((unsigned long *)&__m256i_result2) = 0xf259905a09c23be0; ++ *((unsigned long *)&__m256i_result1) = 0x0000883a00000f20; ++ *((unsigned long *)&__m256i_result0) = 0x6d3c2d3a89167aeb; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4f8000004f800000; ++ *((unsigned long *)&__m256i_op02) = 0x4f7fffbf0000fe00; ++ *((unsigned long *)&__m256i_op01) = 0x000000004f800000; ++ *((unsigned long *)&__m256i_op00) = 0x4f7fffe64f7fffc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfe02fe02fee5fe22; ++ *((unsigned long *)&__m256i_op10) = 0xff49fe4200000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffbf0000fe000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fe020000fe22; ++ *((unsigned long *)&__m256i_result0) = 0xffe6fe42ffc00000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xc06500550055ffab; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x00550000ffab0001; ++ *((unsigned long *)&__m256i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x00550000ffab0001; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000400000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000400000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000400000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000400000000; ++ __m256i_out = __lasx_xvpackev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op12) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op11) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op10) = 0x01fe01fe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01fe01fe00000000; ++ __m256i_out = __lasx_xvpackev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ffffffffff; ++ __m256i_out = __lasx_xvpackev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvpackev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_result3) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result2) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_result1) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000089; ++ __m256i_out = __lasx_xvpackev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000200; ++ __m256i_out = __lasx_xvpackev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op12) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m256i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op10) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m256i_result3) = 0x0080010000800100; ++ *((unsigned long *)&__m256i_result2) = 0x00c0000000c00000; ++ *((unsigned long *)&__m256i_result1) = 0x0080010000800100; ++ *((unsigned long *)&__m256i_result0) = 0x00c0000000c00000; ++ __m256i_out = __lasx_xvpackev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000001fdfffffe02; ++ *((unsigned long *)&__m256i_op01) = 0x000000000001fefe; ++ *((unsigned long *)&__m256i_op00) = 0xffff01fefffeff02; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000fd00ffff02ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001fffeff; ++ *((unsigned long *)&__m256i_result0) = 0xff00fe00feff02ff; ++ __m256i_out = __lasx_xvpackev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8011ffee804c004c; ++ *((unsigned long *)&__m256i_op02) = 0x00faff0500c3ff3c; ++ *((unsigned long *)&__m256i_op01) = 0x80f900f980780078; ++ *((unsigned long *)&__m256i_op00) = 0x0057ffa800ceff31; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffee0000004c0000; ++ *((unsigned long *)&__m256i_result2) = 0xff050000ff3c0000; ++ *((unsigned long *)&__m256i_result1) = 0x00f9000000780000; ++ *((unsigned long *)&__m256i_result0) = 0xffa80000ff310000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000001d0000001d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00001d0000001d00; ++ __m256i_out = __lasx_xvpackev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003fe000000000; ++ __m256i_out = __lasx_xvpackev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x6); ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ff890000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff790000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ff890000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff790000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff790000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff790000; ++ __m256i_out = __lasx_xvpackev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_op01) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfbff0000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfbff0000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000000000; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op02) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op01) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op00) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_result3) = 0xffffffe700000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffe7007b007e; ++ *((unsigned long *)&__m256i_result1) = 0xffffffe700000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffe7007b007e; ++ __m256i_out = __lasx_xvpackev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000008000000; ++ *((unsigned long *)&__m256i_op12) = 0x0003fffc0803fff8; ++ *((unsigned long *)&__m256i_op11) = 0x0000000008000000; ++ *((unsigned long *)&__m256i_op10) = 0x0003fffc0803fff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000fffc0000fff8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000fffc0000fff8; ++ __m256i_out = __lasx_xvpackev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackod.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackod.c +new file mode 100644 +index 000000000..cdd20e881 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpackod.c +@@ -0,0 +1,575 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7f057f0b7f5b007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7f00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result0) = 0x7f7fff7fff7fff00; ++ __m256i_out = __lasx_xvpackod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff00000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvpackod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_op13) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256i_op12) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256i_op11) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256i_op10) = 0x00000fff00000fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result2) = 0xff00ff0fff005f0f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result0) = 0xff00ff0fff005f0f; ++ __m256i_out = __lasx_xvpackod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff000607f7; ++ *((unsigned long *)&__m256i_op12) = 0x000000010017e7d1; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff000607f7; ++ *((unsigned long *)&__m256i_op10) = 0x00000001001807f1; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000e7; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00000007; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvpackod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op02) = 0x0002555500000000; ++ *((unsigned long *)&__m256i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op00) = 0x0002555500000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000005400; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000005400; ++ __m256i_out = __lasx_xvpackod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpackod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_op12) = 0x000000000007fff8; ++ *((unsigned long *)&__m256i_op11) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_op10) = 0x000000000007fff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0007fff8000ffff0; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_op01) = 0xffefffef00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffefffefffefffef; ++ *((unsigned long *)&__m256i_op13) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op12) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result3) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_result1) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff00ff00ff00ff00; ++ __m256i_out = __lasx_xvpackod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_op12) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_op11) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_op10) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000f0000000f000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000f0000000f000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvpackod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op02) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op01) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op00) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000c8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000c8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000022beb03f; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffa2beb040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000022be22be; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fffa2bea2be; ++ *((unsigned long *)&__m256i_result1) = 0x0000000022be22be; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fffa2bea2be; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op12) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op11) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op10) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff10000fff10000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfff1000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff1000000000000; ++ __m256i_out = __lasx_xvpackod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_op13) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op12) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op10) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ff0000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ff0000000000; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000555500005555; ++ *((unsigned long *)&__m256i_op02) = 0x0000555500005555; ++ *((unsigned long *)&__m256i_op01) = 0x0000555500005555; ++ *((unsigned long *)&__m256i_op00) = 0x0000555500005555; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op02) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op00) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000a0008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000a0008; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_op02) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fff8ffc0; ++ *((unsigned long *)&__m256i_op00) = 0x0000ff00fff8ffc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fff80000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fff80000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fff80000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fff80000; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpackod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_result2) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_result1) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff00007fff; ++ __m256i_out = __lasx_xvpackod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickev.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickev.c +new file mode 100644 +index 000000000..66faa74d0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickev.c +@@ -0,0 +1,515 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffff90ffffff81; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffff90ffffff81; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff90ff81; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ff90ff81; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000007f; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffe81; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffe81; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000001341c4000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000001000310000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000033e87ef1; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000002e2100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000011c00; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000e8f1; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000103100; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000002e00; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000004290; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004290; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000004290; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000004290; ++ __m256i_out = __lasx_xvpickev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_op12) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_op11) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_op10) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xbfbfbfbfbfbfbfbf; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op12) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_op11) = 0xa020202020202020; ++ *((unsigned long *)&__m256i_op10) = 0xa020202020206431; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202031; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202031; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0004040404000000; ++ *((unsigned long *)&__m256i_op02) = 0x0004040404000000; ++ *((unsigned long *)&__m256i_op01) = 0x0004040404000000; ++ *((unsigned long *)&__m256i_op00) = 0x0004040404000000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0xf800d0d8ffffeecf; ++ *((unsigned long *)&__m256i_op12) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256i_op11) = 0xf800d0d8ffffeecf; ++ *((unsigned long *)&__m256i_op10) = 0x0000383fffffdf0d; ++ *((unsigned long *)&__m256i_result3) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result2) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0xd0d8eecf383fdf0d; ++ __m256i_out = __lasx_xvpickev_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf80ff20df80ff20; ++ *((unsigned long *)&__m256i_op02) = 0xdfc2ff20df80ffa7; ++ *((unsigned long *)&__m256i_op01) = 0xdf80ff20df80ff20; ++ *((unsigned long *)&__m256i_op00) = 0xdfc2ff20df80ffa7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x80208020c22080a7; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x80208020c22080a7; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000040000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000040000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000400; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000400; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op12) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_op11) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op10) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xe07de0801f20607a; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000800080010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000800080010000; ++ *((unsigned long *)&__m256i_result3) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x8000800080010000; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x8000800080010000; ++ __m256i_out = __lasx_xvpickev_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op12) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op11) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op10) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result3) = 0x9ffffd8020010001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff9fffffff9; ++ *((unsigned long *)&__m256i_result1) = 0x9ffffd8020010001; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff9fffffff9; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvpickev_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000060002000a; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000060002000a; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickev_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickod.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickod.c +new file mode 100644 +index 000000000..a9778809f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickod.c +@@ -0,0 +1,530 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0003f8040002f607; ++ *((unsigned long *)&__m256i_op00) = 0x0002728b00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffff328dfff; ++ *((unsigned long *)&__m256i_op10) = 0x6651bfff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0003f8040002f607; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffff328dfff; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0080200000802000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0080200000802000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00200020ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x1e0000001e000000; ++ *((unsigned long *)&__m256i_result1) = 0x00200020ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x1e0000001e000000; ++ __m256i_out = __lasx_xvpickod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0080200000802000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0080200000802000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00800080ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00800080ffffffff; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpickod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffffe40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000040004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op12) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op11) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op10) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0400040004000400; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xb70036db12c4007e; ++ *((unsigned long *)&__m256i_op02) = 0xb7146213fc1e0049; ++ *((unsigned long *)&__m256i_op01) = 0x000000fefe02fffe; ++ *((unsigned long *)&__m256i_op00) = 0xb71c413b199d04b5; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff017e00ff; ++ *((unsigned long *)&__m256i_op11) = 0x017e00ff017e01fe; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff017e00ff; ++ *((unsigned long *)&__m256i_result3) = 0xb70012c4b714fc1e; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff017e; ++ *((unsigned long *)&__m256i_result1) = 0x0000fe02b71c199d; ++ *((unsigned long *)&__m256i_result0) = 0x017e017e00ff017e; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc080ffff0049ffd2; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0049ffd2; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffeffb9ff9d; ++ *((unsigned long *)&__m256i_op00) = 0x01620133004b0032; ++ *((unsigned long *)&__m256i_op13) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_op12) = 0xffb7ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_op11) = 0x00010000002fff9e; ++ *((unsigned long *)&__m256i_op10) = 0xffb5ff80ffd0ffd8; ++ *((unsigned long *)&__m256i_result3) = 0xc080ffff0049ffd2; ++ *((unsigned long *)&__m256i_result2) = 0x0002ff80ffb70000; ++ *((unsigned long *)&__m256i_result1) = 0x0000fffeffb9ff9d; ++ *((unsigned long *)&__m256i_result0) = 0x00010000002fff9e; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_op12) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_op11) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_op10) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xbabababababababa; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op12) = 0xc6c6c6c68787878a; ++ *((unsigned long *)&__m256i_op11) = 0x000000003f3f3f3c; ++ *((unsigned long *)&__m256i_op10) = 0x8787878a00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003f3fc6c68787; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003f3f87870000; ++ __m256i_out = __lasx_xvpickod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fff003f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fff003f; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007fff; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op01) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000002467db99; ++ *((unsigned long *)&__m256i_op02) = 0x000000003e143852; ++ *((unsigned long *)&__m256i_op01) = 0x000000002467db99; ++ *((unsigned long *)&__m256i_op00) = 0x000000003e143852; ++ *((unsigned long *)&__m256i_op13) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op12) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_op11) = 0x0000000044444443; ++ *((unsigned long *)&__m256i_op10) = 0x7bbbbbbbf7777778; ++ *((unsigned long *)&__m256i_result3) = 0x0000246700003e14; ++ *((unsigned long *)&__m256i_result2) = 0x000044447bbbf777; ++ *((unsigned long *)&__m256i_result1) = 0x0000246700003e14; ++ *((unsigned long *)&__m256i_result0) = 0x000044447bbbf777; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op13) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op12) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m256i_op10) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0006000000020000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0006000000020000; ++ __m256i_out = __lasx_xvpickod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpickod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op02) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op01) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op00) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xbff00000bff00000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xbff00000bff00000; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op02) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op01) = 0x9ff87ef07f7f817f; ++ *((unsigned long *)&__m256i_op00) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x9ff87f7f7f807f7f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x9ff87f7f7f807f7f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffe98; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffe98; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000007f00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000007f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000007f00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000007f00000000; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickod_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op02) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op01) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op00) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvpickod_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve.c +new file mode 100644 +index 000000000..a2edbb80a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve.c +@@ -0,0 +1,130 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x010180068080fff9; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvpickve_d (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickve_w (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op01) = 0x00fe01f000010000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000c40086; ++ __m256i_out = __lasx_xvpickve_d (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickve_d (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_op02) = 0xff820002ff820002; ++ *((unsigned long *)&__m256i_op01) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_op00) = 0xff820002ff820002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0002000200020002; ++ __m256i_out = __lasx_xvpickve_d (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x4000000000000000; ++ __m256i_out = __lasx_xvpickve_d (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickve_w (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvpickve_d (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvpickve_w (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvpickve_w (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve2gr.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve2gr.c +new file mode 100644 +index 000000000..8bd3a8273 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvpickve2gr.c +@@ -0,0 +1,388 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0cc08723ff900001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xcc9b89f2f6cef440; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x7); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ int_result = 0x000000000000ffff; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x6); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff90ff81; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff90ff81; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000007f; ++ int_result = 0x000000000000007f; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000ffffffff; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefdfffffefd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000fffffefd; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_op02) = 0x5555555580000000; ++ *((unsigned long *)&__m256i_op01) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_op00) = 0x5555555580000000; ++ int_result = 0x0000000055555555; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x0002000400000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x0002000200020006; ++ unsigned_int_result = 0x0000000000020006; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op02) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op00) = 0x7ff8000000000000; ++ long_int_result = 0x1f0fdf7f3e3b31d4; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00fe01fc01fe01fc; ++ *((unsigned long *)&__m256i_op02) = 0x012c002c001c0006; ++ *((unsigned long *)&__m256i_op01) = 0x00fe01fc01fe0000; ++ *((unsigned long *)&__m256i_op00) = 0x012c002c001c000a; ++ long_int_result = 0xfe01fc01fe0000; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ unsigned_long_int_result = 0x00000000ffffffff; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_out, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0100; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ long_int_result = 0x00000000ffff0100; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ int_result = 0x000000007ff00000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ unsigned_long_int_result = 0x00000000ffffffff; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000ff; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x6); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0xffffffffffffffff; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffff0100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffff0100000001; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x7); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff0008; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x6); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ long_int_result = 0x000000000000ffff; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op02) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op00) = 0x0010001000100010; ++ unsigned_int_result = 0x0000000000100010; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000100040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000100040; ++ unsigned_int_result = 0x0000000000000040; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x6); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x6); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ long_int_result = 0xffffffffffffffff; ++ long_int_out = __lasx_xvpickve2gr_d (__m256i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ unsigned_int_result = 0x00000000ffffffff; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ unsigned_int_result = 0x00000000ffffffff; ++ unsigned_int_out = __lasx_xvpickve2gr_wu (__m256i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lasx_xvpickve2gr_du (__m256i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000ffffffff; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffd880; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffd880; ++ int_result = 0x0000000000000000; ++ int_out = __lasx_xvpickve2gr_w (__m256i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplgr2vr.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplgr2vr.c +new file mode 100644 +index 000000000..81456bc1b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplgr2vr.c +@@ -0,0 +1,380 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ int_op0 = 0x0000001b3c4c0a5c; ++ *((unsigned long *)&__m256i_result3) = 0x3c4c0a5c3c4c0a5c; ++ *((unsigned long *)&__m256i_result2) = 0x3c4c0a5c3c4c0a5c; ++ *((unsigned long *)&__m256i_result1) = 0x3c4c0a5c3c4c0a5c; ++ *((unsigned long *)&__m256i_result0) = 0x3c4c0a5c3c4c0a5c; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000397541c58; ++ *((unsigned long *)&__m256i_result3) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_result2) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_result1) = 0x97541c5897541c58; ++ *((unsigned long *)&__m256i_result0) = 0x97541c5897541c58; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000400; ++ *((unsigned long *)&__m256i_result3) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result2) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_result0) = 0x0400040004000400; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000084; ++ *((unsigned long *)&__m256i_result3) = 0x0084008400840084; ++ *((unsigned long *)&__m256i_result2) = 0x0084008400840084; ++ *((unsigned long *)&__m256i_result1) = 0x0084008400840084; ++ *((unsigned long *)&__m256i_result0) = 0x0084008400840084; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000020202020; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000020006; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ long_op0 = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000020006; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000020006; ++ __m256i_out = __lasx_xvreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ int_op0 = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve.c +new file mode 100644 +index 000000000..7aa76c2ba +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve.c +@@ -0,0 +1,536 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000001b3c4c0a5c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffefb; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffefb; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000fe; ++ int_op1 = 0x0000000059815d00; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000fe; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op02) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op01) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op00) = 0x555555ab555555ab; ++ int_op1 = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result2) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result1) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result0) = 0x555555ab555555ab; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100010001; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x00000000012e2110; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_result2) = 0x0202020202020202; ++ *((unsigned long *)&__m256i_result1) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result0) = 0x1010101010101010; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ int_op1 = 0x0000000000000400; ++ *((unsigned long *)&__m256i_result3) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result2) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result1) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result0) = 0x003f003f003f003f; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op02) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op01) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op00) = 0x003f003f003f003f; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result2) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result1) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result0) = 0x003f003f003f003f; ++ __m256i_out = __lasx_xvreplve_w (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000003f0000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op02) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_op01) = 0xe161616161616161; ++ *((unsigned long *)&__m256i_op00) = 0xe161616161614e60; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_result2) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_result1) = 0xe161616161614e60; ++ *((unsigned long *)&__m256i_result0) = 0xe161616161614e60; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ int_op1 = 0x00000000000000ac; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000080; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000400; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00d5007f00ffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op01) = 0xff00d5007f00ffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ffffff00ffff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_w (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000020202020; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvreplve_w (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffff7fffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffff7fffff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xc192181230000000; ++ *((unsigned long *)&__m256i_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xc192181230000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff00ff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff00ff; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fef7fef7fef7fef; ++ *((unsigned long *)&__m256i_result2) = 0x7fef7fef7fef7fef; ++ *((unsigned long *)&__m256i_result1) = 0x7fef7fef7fef7fef; ++ *((unsigned long *)&__m256i_result0) = 0x7fef7fef7fef7fef; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffff00ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffff00ffffffff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff0000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f010700c70106; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f010700c70106; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0106010601060106; ++ *((unsigned long *)&__m256i_result2) = 0x0106010601060106; ++ *((unsigned long *)&__m256i_result1) = 0x0106010601060106; ++ *((unsigned long *)&__m256i_result0) = 0x0106010601060106; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_h (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve_w (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000003fff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000003fff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result2) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result0) = 0x4040404040404040; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000404; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000404; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_result2) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_result1) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_result0) = 0x0404040404040404; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000800080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000202; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000202; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000202; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x000000003ddc5dac; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_d (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000002; ++ int_op1 = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve_b (__m256i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve0.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve0.c +new file mode 100644 +index 000000000..a2bc2da52 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplve0.c +@@ -0,0 +1,471 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffeffffff88; ++ *((unsigned long *)&__m256i_op02) = 0x61e0000000000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffeffffff88; ++ *((unsigned long *)&__m256i_op00) = 0x61e0000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff80fe; ++ *((unsigned long *)&__m256i_op02) = 0xd52aaaaa555555ab; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffff80fe; ++ *((unsigned long *)&__m256i_op00) = 0xd52aaaaa555555ab; ++ *((unsigned long *)&__m256i_result3) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result2) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result1) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_result0) = 0x555555ab555555ab; ++ __m256i_out = __lasx_xvreplve0_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result2) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result0) = 0x8080808080808080; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fff3fff; ++ *((unsigned long *)&__m256i_op01) = 0x3fff3fff3fff4000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000403f3fff; ++ *((unsigned long *)&__m256i_result3) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result2) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result1) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result0) = 0x3fff3fff3fff3fff; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000001; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000001; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000020202020; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_q (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x0007fd00000f02ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001fffeff; ++ *((unsigned long *)&__m256i_op00) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result3) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result2) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result1) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result0) = 0xff00fe00feff02ff; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfc00ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000100fe000100fe; ++ *((unsigned long *)&__m256i_op01) = 0xfc00ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000100fe000100fe; ++ *((unsigned long *)&__m256i_result3) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result2) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result1) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m256i_result0) = 0x00fe00fe00fe00fe; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result2) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result0) = 0x4040404040404040; ++ __m256i_out = __lasx_xvreplve0_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_q (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000781; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000064; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_q (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffe20001dfe1f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_q (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve0_q (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op02) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_op01) = 0xffe0047d00e00480; ++ *((unsigned long *)&__m256i_op00) = 0x001fc0200060047a; ++ *((unsigned long *)&__m256i_result3) = 0x047a047a047a047a; ++ *((unsigned long *)&__m256i_result2) = 0x047a047a047a047a; ++ *((unsigned long *)&__m256i_result1) = 0x047a047a047a047a; ++ *((unsigned long *)&__m256i_result0) = 0x047a047a047a047a; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x037fe01f001fe020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x037fe01f001fe020; ++ *((unsigned long *)&__m256i_result3) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result2) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_result0) = 0x2020202020202020; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op02) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op01) = 0xff0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op00) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result3) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result2) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result1) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_result0) = 0x0d0d0d0d0d0d0d0d; ++ __m256i_out = __lasx_xvreplve0_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op02) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op01) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op00) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result3) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result2) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result1) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result0) = 0x0202010202020102; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff00ff00ff; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000001; ++ __m256i_out = __lasx_xvreplve0_d (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op02) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op00) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_result3) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_result2) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_result1) = 0x800080ff800080ff; ++ *((unsigned long *)&__m256i_result0) = 0x800080ff800080ff; ++ __m256i_out = __lasx_xvreplve0_w (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_q (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvreplve0_q (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_result3) = 0x97a297a297a297a2; ++ *((unsigned long *)&__m256i_result2) = 0x97a297a297a297a2; ++ *((unsigned long *)&__m256i_result1) = 0x97a297a297a297a2; ++ *((unsigned long *)&__m256i_result0) = 0x97a297a297a297a2; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_h (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvreplve0_b (__m256i_op0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplvei.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplvei.c +new file mode 100644 +index 000000000..9346f9bfb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvreplvei.c +@@ -0,0 +1,20 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf4i_b.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf4i_b.c +new file mode 100644 +index 000000000..c8a00ca89 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf4i_b.c +@@ -0,0 +1,430 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00007ffffffff7ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x49d8080067f4f81f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007f00fffff7ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xd8490849f467f867; ++ __m256i_out = __lasx_xvshuf4i_b (__m256i_op0, 0xb7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_b (__m256i_op0, 0xdb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_b (__m256i_op0, 0x95); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffb3b4; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff5ffff4738; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffb3b4; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff5ffff4738; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvshuf4i_b (__m256i_op0, 0xee); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_b (__m256i_op0, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_b (__m256i_op0, 0x6f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_b (__m256i_op0, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00007ffffffff7ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x49d8080067f4f81f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7ffff7ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x080008000800f81f; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0xa8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op02) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op01) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op00) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_result3) = 0xc5c4c5c5c5c5c5c5; ++ *((unsigned long *)&__m256i_result2) = 0xc5c545c545c545c5; ++ *((unsigned long *)&__m256i_result1) = 0xc5c4c5c5c5c5c5c5; ++ *((unsigned long *)&__m256i_result0) = 0xc5c545c545c545c5; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0xf7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff0000; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0xa7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result3) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result2) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result1) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result0) = 0xff1cff1cff1cff1c; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0xdc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_op02) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0020; ++ *((unsigned long *)&__m256i_op00) = 0xffff8001ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff8001ffff8001; ++ *((unsigned long *)&__m256i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff8001ffff8001; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0x6e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0x9f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op02) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op00) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0002ffff00020002; ++ *((unsigned long *)&__m256i_result2) = 0x04f504f104f504f5; ++ *((unsigned long *)&__m256i_result1) = 0x0002ffff00020002; ++ *((unsigned long *)&__m256i_result0) = 0x04f504f104f504f5; ++ __m256i_out = __lasx_xvshuf4i_h (__m256i_op0, 0x65); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256i_result2) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256i_result0) = 0x1e18000000000000; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0xfe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0x64); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op02) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_op01) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_op00) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_result3) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_result2) = 0x45c5c5c545c5c5c5; ++ *((unsigned long *)&__m256i_result1) = 0xc5c5c5c4c5c5c5c4; ++ *((unsigned long *)&__m256i_result0) = 0x45c5c5c545c5c5c5; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0xb0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000f9f900; ++ *((unsigned long *)&__m256i_op02) = 0x79f9f9f900f9f9e0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000f9f900; ++ *((unsigned long *)&__m256i_op00) = 0x79f9f9f900f9f900; ++ *((unsigned long *)&__m256i_result3) = 0x00f9f90079f9f9f9; ++ *((unsigned long *)&__m256i_result2) = 0x79f9f9f900000000; ++ *((unsigned long *)&__m256i_result1) = 0x00f9f90079f9f9f9; ++ *((unsigned long *)&__m256i_result0) = 0x79f9f9f900000000; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0x97); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_op01) = 0x000000007aff7c00; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffd017d00; ++ *((unsigned long *)&__m256i_result3) = 0x7aff7c0000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfd017d0000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7aff7c0000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfd017d0000000000; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0xb3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_op02) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_op01) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_op00) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_result3) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_result2) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_result1) = 0xc3f0c3f0c3f0c3f0; ++ *((unsigned long *)&__m256i_result0) = 0xc3f0c3f0c3f0c3f0; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0xf4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_result3) = 0xff81ff7dffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_result1) = 0xff81ff7dffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff81ff7d; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0x28); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000002000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000020ff790020; ++ *((unsigned long *)&__m256i_op01) = 0x0000002000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000020ff790020; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000020; ++ __m256i_out = __lasx_xvshuf4i_w (__m256i_op0, 0xa5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0101010183f95466; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x01010101d58efe94; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0101010183f95466; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x01010101d58efe94; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0xa7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0xd9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_op02) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_op01) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_op00) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result2) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result1) = 0x00001fff00001fff; ++ *((unsigned long *)&__m256i_result0) = 0x00001fff00001fff; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff80be0000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000f0f0002; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff80be0000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000f1002; ++ *((unsigned long *)&__m256i_op13) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x80000000ff800000; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0xdb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op12) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op11) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op10) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x43ef878780000009; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0x36); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0x5a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff00017fff0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_result2) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_result0) = 0x04f104f104f504ed; ++ __m256i_out = __lasx_xvshuf4i_d (__m256i_op0, __m256i_op1, 0x7e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf_b.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf_b.c +new file mode 100644 +index 000000000..641ea2315 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvshuf_b.c +@@ -0,0 +1,761 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000007070707; ++ *((unsigned long *)&__m256i_op02) = 0x0102040000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000020100; ++ *((unsigned long *)&__m256i_op00) = 0x0703020000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfe02fe02fee5fe22; ++ *((unsigned long *)&__m256i_op10) = 0xff49fe4200000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffcfa; ++ *((unsigned long *)&__m256i_op11) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0xfffffff8fffffff8; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0xfffffff8fc000000; ++ *((unsigned long *)&__m256i_result3) = 0xfafafafafafafafa; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000fefefe; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x3ff0010000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x3ff0010000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op22) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op21) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op20) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000003ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000077fff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_b (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffefe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffefe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x67eee33567eee435; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x67eee33567eee435; ++ *((unsigned long *)&__m256i_op23) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op12) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op11) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op10) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7575ffff75757595; ++ *((unsigned long *)&__m256i_op02) = 0x7575ffff7575f575; ++ *((unsigned long *)&__m256i_op01) = 0x7575ffff75757595; ++ *((unsigned long *)&__m256i_op00) = 0x7575ffff7575f575; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op23) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op22) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op21) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_op20) = 0x7575757575757575; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_result3) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_result2) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_result1) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_result0) = 0xf800f800f800f800; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000f0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_op21) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x000000ffff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_result2) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_result1) = 0xff88ff88ff880000; ++ *((unsigned long *)&__m256i_result0) = 0xff88ff88ff880000; ++ __m256i_out = __lasx_xvshuf_h (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000010000ffe1; ++ *((unsigned long *)&__m256i_op02) = 0x0000000101001e18; ++ *((unsigned long *)&__m256i_op01) = 0x000000010000ffe1; ++ *((unsigned long *)&__m256i_op00) = 0x0000000101001e18; ++ *((unsigned long *)&__m256i_op13) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op12) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op11) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op10) = 0x98111cca98111cca; ++ *((unsigned long *)&__m256i_op23) = 0x000000010000ffe1; ++ *((unsigned long *)&__m256i_op22) = 0x0000000101001e18; ++ *((unsigned long *)&__m256i_op21) = 0x000000010000ffe1; ++ *((unsigned long *)&__m256i_op20) = 0x0000000101001e18; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000101001e18; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000101001e18; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x80008000b3e8fef1; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x80008000802ea100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op20) = 0x00000000012e2110; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x012e2110012e2110; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000082a54290; ++ *((unsigned long *)&__m256i_op02) = 0x00000000028aa700; ++ *((unsigned long *)&__m256i_op01) = 0x0000000082a54290; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54287; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000002a542a; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x000000007fc00000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fc00000; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fc00000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fc00000; ++ *((unsigned long *)&__m256i_op23) = 0xdfffffffdfffffff; ++ *((unsigned long *)&__m256i_op22) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op21) = 0xdfffffffdfffffff; ++ *((unsigned long *)&__m256i_op20) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0001000104000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0001000104000200; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op23) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op22) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op21) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op20) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_result3) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_result2) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_result1) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_result0) = 0x0004000500040005; ++ __m256i_out = __lasx_xvshuf_w (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op12) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op11) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op10) = 0x555555ab555555ab; ++ *((unsigned long *)&__m256i_op23) = 0x0000000080008000; ++ *((unsigned long *)&__m256i_op22) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000080008000; ++ *((unsigned long *)&__m256i_op20) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op22) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000fffffe01fe52; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff01ff02; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffffe01fe52; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff01ff02; ++ *((unsigned long *)&__m256i_op13) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000080008001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000080008001; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op11) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op23) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op22) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_op21) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op20) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_result3) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_result1) = 0x000000ff800000ff; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff800000ff; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000002000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000002000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000080040; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffeb8649d0d6250; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffeb8649d0d6250; ++ *((unsigned long *)&__m256i_op13) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op12) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op11) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op10) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op23) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op22) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op21) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op20) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op23) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op22) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvshuf_d (__m256i_op0, __m256i_op1, __m256i_op2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvsll-xvsrl-instr.patch
Added
@@ -0,0 +1,5611 @@ +From e90910ab68c43259f898fb7b2cba02d4eb457428 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:44:49 +0800 +Subject: PATCH 106/124 LoongArch: Add tests for ASX vector xvsll/xvsrl + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvsll.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvslli.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsllwil-1.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsllwil-2.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrl.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrli.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrln.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrlni.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrlr.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrlri.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrlrn.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvsrlrni.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvsll.c | 425 +++++++++++ + .../loongarch/vector/lasx/lasx-xvslli.c | 416 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsllwil-1.c | 339 +++++++++ + .../loongarch/vector/lasx/lasx-xvsllwil-2.c | 350 +++++++++ + .../loongarch/vector/lasx/lasx-xvsrl.c | 650 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrli.c | 405 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsrln.c | 425 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsrlni.c | 680 ++++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrlr.c | 515 +++++++++++++ + .../loongarch/vector/lasx/lasx-xvsrlri.c | 416 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsrlrn.c | 410 +++++++++++ + .../loongarch/vector/lasx/lasx-xvsrlrni.c | 455 ++++++++++++ + 12 files changed, 5486 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsll.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslli.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrl.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrli.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrln.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlni.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlri.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrni.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsll.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsll.c +new file mode 100644 +index 000000000..7179e715c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsll.c +@@ -0,0 +1,425 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00001f41ffffbf00; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00001f41ffffbf00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffe0000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000fffefe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000fffefe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000808080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffcfa; ++ *((unsigned long *)&__m256i_op01) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefefffffcfa; ++ *((unsigned long *)&__m256i_result1) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvsll_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfff2f7bcfff2f7bd; ++ *((unsigned long *)&__m256i_op12) = 0xfff2f93bfff2fff2; ++ *((unsigned long *)&__m256i_op11) = 0xfff2f7bcfff2f7bd; ++ *((unsigned long *)&__m256i_op10) = 0xfff2f93bfff2fff2; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffcf800fffcfffc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffcfffc; ++ __m256i_out = __lasx_xvsll_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffffe40; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fff0e400; ++ __m256i_out = __lasx_xvsll_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x5980000000000000; ++ __m256i_out = __lasx_xvsll_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result2) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_result0) = 0x8080808080808080; ++ __m256i_out = __lasx_xvsll_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000800000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000001ff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001ff8000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001ff8000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff0000ffff; ++ __m256i_out = __lasx_xvsll_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvsll_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff800000000000; ++ __m256i_out = __lasx_xvsll_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op02) = 0xff00010001000100; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op00) = 0xff00010001000100; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result2) = 0x800000ff800000ff; ++ *((unsigned long *)&__m256i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result0) = 0x800000ff800000ff; ++ __m256i_out = __lasx_xvsll_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_op12) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_op11) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_op10) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsll_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslli.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslli.c +new file mode 100644 +index 000000000..003e29b67 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvslli.c +@@ -0,0 +1,416 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fa022a01a401e5; ++ *((unsigned long *)&__m256i_op02) = 0x030d03aa0079029b; ++ *((unsigned long *)&__m256i_op01) = 0x024c01f901950261; ++ *((unsigned long *)&__m256i_op00) = 0x008102c2008a029f; ++ *((unsigned long *)&__m256i_result3) = 0x54000000ca000000; ++ *((unsigned long *)&__m256i_result2) = 0x5400000036000000; ++ *((unsigned long *)&__m256i_result1) = 0xf2000000c2000000; ++ *((unsigned long *)&__m256i_result0) = 0x840000003e000000; ++ __m256i_out = __lasx_xvslli_w (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff1001100100000; ++ *((unsigned long *)&__m256i_op02) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfff1001100100000; ++ *((unsigned long *)&__m256i_op00) = 0x0010100000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfcc4004400400000; ++ *((unsigned long *)&__m256i_result2) = 0x0040400000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfcc4004400400000; ++ *((unsigned long *)&__m256i_result0) = 0x0040400000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_d (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_op02) = 0xffffffef000004ea; ++ *((unsigned long *)&__m256i_op01) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_op00) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_result3) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_result2) = 0xffffffef000004ea; ++ *((unsigned long *)&__m256i_result1) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_result0) = 0xffffffefffffffef; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffbf4; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_result3) = 0xf800f800f800c000; ++ *((unsigned long *)&__m256i_result2) = 0xf800f800f800a000; ++ *((unsigned long *)&__m256i_result1) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_result0) = 0xf800f800f800e000; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffefefffffefe; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0100010001000000; ++ *((unsigned long *)&__m256i_result0) = 0x0100010001000000; ++ __m256i_out = __lasx_xvslli_d (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xf000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xf000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_w (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1616161616161616; ++ *((unsigned long *)&__m256i_op02) = 0x161616167fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7ffe16167f161616; ++ *((unsigned long *)&__m256i_op00) = 0x161616167fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x2c2c2c2c2c2c2c2c; ++ *((unsigned long *)&__m256i_result2) = 0x2c2c2c2cfefefefe; ++ *((unsigned long *)&__m256i_result1) = 0xfefc2c2cfe2c2c2c; ++ *((unsigned long *)&__m256i_result0) = 0x2c2c2c2cfefefefe; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m256i_result2) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m256i_result1) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m256i_result0) = 0xf8f8f8f8f8f8f8f8; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1f60000000c00000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1f60000000c00000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x60000000c0000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x60000000c0000000; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff80ff80ff80ff80; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff80ff80ff80ff80; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result2) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result0) = 0x0000008000000080; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00080008000801ff; ++ *((unsigned long *)&__m256i_op02) = 0x0008000800080008; ++ *((unsigned long *)&__m256i_op01) = 0x00080008000801ff; ++ *((unsigned long *)&__m256i_op00) = 0x0008000800080008; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_d (__m256i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_result2) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_result1) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_result0) = 0xf0f0f0f0f0f0f0f0; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_w (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_w (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x03f0000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x03f0000000000000; ++ __m256i_out = __lasx_xvslli_d (__m256i_op0, 0x34); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_w (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffff80000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffff80000; ++ __m256i_out = __lasx_xvslli_d (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefefefefefe; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_result2) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_result1) = 0xf800f800f800f800; ++ *((unsigned long *)&__m256i_result0) = 0xf800f800f800f800; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op02) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_result2) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_result1) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_result0) = 0x0404000004040000; ++ __m256i_out = __lasx_xvslli_w (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_d (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000c040c0; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000c040c0; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff000000; ++ __m256i_out = __lasx_xvslli_d (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvslli_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-1.c +new file mode 100644 +index 000000000..ef3a47da5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-1.c +@@ -0,0 +1,339 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffe0ffe0ffe0ffe0; ++ *((unsigned long *)&__m256i_result2) = 0xffe0ffe0ffe0ffe0; ++ *((unsigned long *)&__m256i_result1) = 0xffe0ffe0ffe0ffe0; ++ *((unsigned long *)&__m256i_result0) = 0xffe0ffe0ffe0ffe0; ++ __m256i_out = __lasx_xvsllwil_h_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000003f0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000003f0; ++ __m256i_out = __lasx_xvsllwil_h_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_h_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_h_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op02) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_op01) = 0x0000000080000009; ++ *((unsigned long *)&__m256i_op00) = 0x43ef878780000009; ++ *((unsigned long *)&__m256i_result3) = 0x0218ff78fc38fc38; ++ *((unsigned long *)&__m256i_result2) = 0xfc00000000000048; ++ *((unsigned long *)&__m256i_result1) = 0x0218ff78fc38fc38; ++ *((unsigned long *)&__m256i_result0) = 0xfc00000000000048; ++ __m256i_out = __lasx_xvsllwil_h_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffc0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfff0fff0fff0fc00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff0fff0fff0fc00; ++ __m256i_out = __lasx_xvsllwil_h_b (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_h_b (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfc00000000000000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffc00fffffc00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffc00fffffc00; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_op01) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000a000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000a000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result2) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result1) = 0x0000400000004000; ++ *((unsigned long *)&__m256i_result0) = 0x0000400000004000; ++ __m256i_out = __lasx_xvsllwil_w_h (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffefffffefd; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffbf4; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffffffffffc; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xdbc8000000003fff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffbff1ffffbff1; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffbff1ffffbff1; ++ *((unsigned long *)&__m256i_result3) = 0xfffffeffc4000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffeffc4000000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffeffc4000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffeffc4000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op02) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op00) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_result3) = 0xfffffe05fc47b400; ++ *((unsigned long *)&__m256i_result2) = 0xfffffe06003fc000; ++ *((unsigned long *)&__m256i_result1) = 0xfffffe05fc47b400; ++ *((unsigned long *)&__m256i_result0) = 0xfffffe06003fc000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000feccfecc; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000feccfecc; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op02) = 0x7fe363637fe36364; ++ *((unsigned long *)&__m256i_op01) = 0x7fe36364661af18f; ++ *((unsigned long *)&__m256i_op00) = 0x7fe363637fe36364; ++ *((unsigned long *)&__m256i_result3) = 0x00001ff8d8d8c000; ++ *((unsigned long *)&__m256i_result2) = 0x00001ff8d8d90000; ++ *((unsigned long *)&__m256i_result1) = 0x00001ff8d8d8c000; ++ *((unsigned long *)&__m256i_result0) = 0x00001ff8d8d90000; ++ __m256i_out = __lasx_xvsllwil_d_w (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-2.c +new file mode 100644 +index 000000000..76651af63 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsllwil-2.c +@@ -0,0 +1,350 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_result3) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result1) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000004000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x03fc03fc03f803f8; ++ *((unsigned long *)&__m256i_result2) = 0x03fc03fc03f803f8; ++ *((unsigned long *)&__m256i_result1) = 0x03fc03fc03f803f8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01fe01fe01fe01fe; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op02) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x1f0fdf7f3e3b31d4; ++ *((unsigned long *)&__m256i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x01fc03e000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x01fc03e000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00fe01e000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00fe01e000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op02) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_op01) = 0x07fee332883f86b0; ++ *((unsigned long *)&__m256i_op00) = 0x07fed3c8f7ad28d0; ++ *((unsigned long *)&__m256i_result3) = 0x01c03f8034c03200; ++ *((unsigned long *)&__m256i_result2) = 0x3dc02b400a003400; ++ *((unsigned long *)&__m256i_result1) = 0x01c03f8034c03200; ++ *((unsigned long *)&__m256i_result0) = 0x3dc02b400a003400; ++ __m256i_out = __lasx_xvsllwil_hu_bu (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000054; ++ *((unsigned long *)&__m256i_op02) = 0x00aa000000ac00fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000054; ++ *((unsigned long *)&__m256i_op00) = 0x00aa000000ac00fe; ++ *((unsigned long *)&__m256i_result3) = 0x0002a80000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0002b0000003f800; ++ *((unsigned long *)&__m256i_result1) = 0x0002a80000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0002b0000003f800; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256i_op02) = 0x41d8585858400000; ++ *((unsigned long *)&__m256i_op01) = 0xc1be9e9e9f000000; ++ *((unsigned long *)&__m256i_op00) = 0x41d8585858400000; ++ *((unsigned long *)&__m256i_result3) = 0x1076000016160000; ++ *((unsigned long *)&__m256i_result2) = 0x1610000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1076000016160000; ++ *((unsigned long *)&__m256i_result0) = 0x1610000000000000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result1) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000008000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_wu_hu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007f00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x311d73ad3ec2064a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000001fc000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000c475ceb40000; ++ *((unsigned long *)&__m256i_result0) = 0x0000fb0819280000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff0000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0004040404000000; ++ *((unsigned long *)&__m256i_result2) = 0x0004040404000000; ++ *((unsigned long *)&__m256i_result1) = 0x0004040404000000; ++ *((unsigned long *)&__m256i_result0) = 0x0004040404000000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000007c8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000007c8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000007c8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000007c8; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_result3) = 0x0000000086000000; ++ *((unsigned long *)&__m256i_result2) = 0x00040ff288000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000086000000; ++ *((unsigned long *)&__m256i_result0) = 0x00040ff288000000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fff000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000001ffe00000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000001ffe00000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op02) = 0x80000000ffc8ff88; ++ *((unsigned long *)&__m256i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op00) = 0x80000000ffc8ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001ff91ff100000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001ff91ff100000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000008c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000008c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000001180000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001180000000; ++ __m256i_out = __lasx_xvsllwil_du_wu (__m256i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrl.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrl.c +new file mode 100644 +index 000000000..1d591c35c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrl.c +@@ -0,0 +1,650 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op11) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op10) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_op02) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_op01) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_op00) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_result2) = 0x247fe49409620040; ++ *((unsigned long *)&__m256i_result1) = 0x6580668200fe0002; ++ *((unsigned long *)&__m256i_result0) = 0x6580668200fe0002; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_op02) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_op01) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_op00) = 0xff874dc687870000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_result2) = 0xffc6cc05c64d960e; ++ *((unsigned long *)&__m256i_result1) = 0x00000000003f7e3f; ++ *((unsigned long *)&__m256i_result0) = 0xff874dc687870000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffba0c05; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffba0c05; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000483800; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xff00ffffff00ffff; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_op12) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_op10) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000200; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op12) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op11) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_op10) = 0x000000000001fffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000080000000800; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m256i_result1) = 0x7fe37fe3001d001d; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff0000; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001010800; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001010800; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op02) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op01) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op00) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m256i_op13) = 0x000008e4bfc4eff0; ++ *((unsigned long *)&__m256i_op12) = 0x0000001ffee10000; ++ *((unsigned long *)&__m256i_op11) = 0x000008e4bfc4eff0; ++ *((unsigned long *)&__m256i_op10) = 0x0000001ffee10000; ++ *((unsigned long *)&__m256i_result3) = 0x0d0d0d000000000d; ++ *((unsigned long *)&__m256i_result2) = 0x0d0d0d0000060d0d; ++ *((unsigned long *)&__m256i_result1) = 0x0d0d0d000000000d; ++ *((unsigned long *)&__m256i_result0) = 0x0d0d0d0000060d0d; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op13) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_op12) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_op11) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_op10) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000010; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op12) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op10) = 0x0000000e0000000d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffff03ffffff07; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffff03ffffff07; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op12) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_op11) = 0x0000800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x80008000fff98000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrl_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000040404000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000040404000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000040004000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m256i_result0) = 0x0000000040404040; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe01fe01fd02fd02; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_op01) = 0xfe01fe01fd02fd02; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fc03fc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000405; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000405; ++ *((unsigned long *)&__m256i_result3) = 0xfe01fe017e81fd02; ++ *((unsigned long *)&__m256i_result2) = 0x000000003fc001fe; ++ *((unsigned long *)&__m256i_result1) = 0xfe01fe017e81fd02; ++ *((unsigned long *)&__m256i_result0) = 0x000000003fc001fe; ++ __m256i_out = __lasx_xvsrl_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op12) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_op11) = 0x000000010000685e; ++ *((unsigned long *)&__m256i_op10) = 0x000020a4ffffbe4f; ++ *((unsigned long *)&__m256i_result3) = 0x00000003ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0001ffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000003ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0001ffffffffffff; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op13) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_op11) = 0x1c1c1c1c1c1c1c1c; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffff00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000001ffff8000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000001ffff8000; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op02) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op01) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op00) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_result2) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_result1) = 0xfd02fd02fd02fd02; ++ *((unsigned long *)&__m256i_result0) = 0xfd02fd02fd02fd02; ++ __m256i_out = __lasx_xvsrl_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0005fff9; ++ *((unsigned long *)&__m256i_op02) = 0x04f004f204f204f0; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0005fff9; ++ *((unsigned long *)&__m256i_op00) = 0x04f004f204f204f0; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000002780; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000002780; ++ __m256i_out = __lasx_xvsrl_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrli.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrli.c +new file mode 100644 +index 000000000..e8696701f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrli.c +@@ -0,0 +1,405 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000050005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1010101110101011; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1111111211111112; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000004444; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffcc8000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007dfdff4b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x003ffff300000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000001f7f7f; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x9240f24a84b18025; ++ *((unsigned long *)&__m256i_op02) = 0x9240f24a84b18025; ++ *((unsigned long *)&__m256i_op01) = 0xb2c0b341807f8006; ++ *((unsigned long *)&__m256i_op00) = 0xb2c0b341807f8006; ++ *((unsigned long *)&__m256i_result3) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_result2) = 0x009200f200840080; ++ *((unsigned long *)&__m256i_result1) = 0x00b200b300800080; ++ *((unsigned long *)&__m256i_result0) = 0x00b200b300800080; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001ffff0001ffff; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffcb423a587053; ++ *((unsigned long *)&__m256i_op02) = 0x6d46f43e71141b81; ++ *((unsigned long *)&__m256i_op01) = 0xffffcb423a584528; ++ *((unsigned long *)&__m256i_op00) = 0x9bdf36c8d78158a1; ++ *((unsigned long *)&__m256i_result3) = 0x000000000007fffe; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000036a37; ++ *((unsigned long *)&__m256i_result1) = 0x000000000007fffe; ++ *((unsigned long *)&__m256i_result0) = 0x000000000004def9; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0889088908810881; ++ *((unsigned long *)&__m256i_op02) = 0x0081010000810100; ++ *((unsigned long *)&__m256i_op01) = 0x0889088900810088; ++ *((unsigned long *)&__m256i_op00) = 0x0081010000810100; ++ *((unsigned long *)&__m256i_result3) = 0x0004448444844084; ++ *((unsigned long *)&__m256i_result2) = 0x0000408080004080; ++ *((unsigned long *)&__m256i_result1) = 0x0004448444804080; ++ *((unsigned long *)&__m256i_result0) = 0x0000408080004080; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000001d001d; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000001d001d; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000030003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000030003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x22); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000077fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000307; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000014402080144; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000a0010400a; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000a0010400a; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000598; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000598; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f807f80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f807f80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff00; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0001ffff0001ffff; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_d (__m256i_op0, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x3fffffff3fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x3fffffff3fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_result2) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_result1) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_result0) = 0x00003fff00003fff; ++ __m256i_out = __lasx_xvsrli_w (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_result3) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result2) = 0x3fff3fff3fff3fc4; ++ *((unsigned long *)&__m256i_result1) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m256i_result0) = 0x3fff3fff3fff3fc4; ++ __m256i_out = __lasx_xvsrli_h (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrln.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrln.c +new file mode 100644 +index 000000000..d54991051 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrln.c +@@ -0,0 +1,425 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000003868686a20; ++ *((unsigned long *)&__m256i_op02) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_op01) = 0x0000003868686a20; ++ *((unsigned long *)&__m256i_op00) = 0x0045b8ae81bce1d8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00386a20b8aee1d8; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00386a20b8aee1d8; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_op12) = 0x2020000020200000; ++ *((unsigned long *)&__m256i_op11) = 0x0008000001010000; ++ *((unsigned long *)&__m256i_op10) = 0x0101000001010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_op11) = 0x017e00ff017e00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff017e01fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x88888a6d0962002e; ++ *((unsigned long *)&__m256i_op02) = 0xdb8a3109fe0f0020; ++ *((unsigned long *)&__m256i_op01) = 0x0000007fff01fffb; ++ *((unsigned long *)&__m256i_op00) = 0xdb8e20990cce025a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xff01ff3400000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff83ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0962002efe0f0020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff01fffb8667012d; ++ __m256i_out = __lasx_xvsrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffeffeb; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fb7afb62; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fffeffeb; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fb7afb62; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffeffebfb7afb62; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffeffebfb7afb62; ++ __m256i_out = __lasx_xvsrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000040; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_op02) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x00ff010000ff017e; ++ *((unsigned long *)&__m256i_op00) = 0x01fe01ae00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_op11) = 0x0000000a00000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000010000000a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff017e6b803fc0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff017e6b803fc0; ++ __m256i_out = __lasx_xvsrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000781; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000078100000064; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_op02) = 0xa1a1a1a15e5e5e5e; ++ *((unsigned long *)&__m256i_op01) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_op00) = 0xa1a1a1a15e5e5e5e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xa1a1a1a1a1a15e5e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xa1a1a1a1a1a15e5e; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op12) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_op11) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op10) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_op12) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_op11) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_op10) = 0x0080000000800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_op12) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_op11) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_op10) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000027; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffff10; ++ *((unsigned long *)&__m256i_op13) = 0x1716151417161514; ++ *((unsigned long *)&__m256i_op12) = 0x1716151417161514; ++ *((unsigned long *)&__m256i_op11) = 0x1716151417161514; ++ *((unsigned long *)&__m256i_op10) = 0x1716151417161514; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0fff0fff0fff0fff; ++ __m256i_out = __lasx_xvsrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlni.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlni.c +new file mode 100644 +index 000000000..0fb6483cf +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlni.c +@@ -0,0 +1,680 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x7f00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_b_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffc500000002d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000034; ++ *((unsigned long *)&__m256i_op13) = 0xbfa3e127c147721f; ++ *((unsigned long *)&__m256i_op12) = 0x1729c173836edfbe; ++ *((unsigned long *)&__m256i_op11) = 0xdf91f111808007fb; ++ *((unsigned long *)&__m256i_op10) = 0x5ff1f90ffffbf30f; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ff280016; ++ *((unsigned long *)&__m256i_result2) = 0xd193a30f94b9b7df; ++ *((unsigned long *)&__m256i_result1) = 0x000000000001001a; ++ *((unsigned long *)&__m256i_result0) = 0xc88840fdf887fd87; ++ __m256i_out = __lasx_xvsrlni_b_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffff00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000f; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffc5556aaa8; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffc5556aaa8; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x555555553f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000007070205; ++ *((unsigned long *)&__m256i_result2) = 0x0000000002020100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000007070205; ++ *((unsigned long *)&__m256i_result0) = 0x0000000002020100; ++ __m256i_out = __lasx_xvsrlni_b_h (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x5980000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xfffffefe00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000003ff000003ff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x36); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x73); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffe01fe01f; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffe01fe01f; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffe01fe01f; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffe01fe01f; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000fe01020b0001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000fe01020b0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0fff0fff00000020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0fff0fff00000020; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op02) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_op01) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op00) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x01fb16ef98f97e90; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x01fb16ef98f97e90; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffa0078fffa0074; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffa2078fffa2074; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffa2078fffa2074; ++ *((unsigned long *)&__m256i_result3) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m256i_result2) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m256i_result1) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m256i_result0) = 0x01ff01ff01ff01ff; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003e6c0000cb7a; ++ *((unsigned long *)&__m256i_op01) = 0x0000401000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003e6c0000cb7a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x40000000b000032d; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x40000000b000032d; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op12) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op11) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_op10) = 0x007f00ff007f00ff; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_result2) = 0x01fc03fc01fc03fc; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m256i_result0) = 0x01fc03fc01fc03fc; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ef0120; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ef0120; ++ *((unsigned long *)&__m256i_op13) = 0x00000000e9ece9ec; ++ *((unsigned long *)&__m256i_op12) = 0x00000000e9ece9ec; ++ *((unsigned long *)&__m256i_op11) = 0x00000000e9ece9ec; ++ *((unsigned long *)&__m256i_op10) = 0x00000000e9ece9ec; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ff00ff0120; ++ *((unsigned long *)&__m256i_result2) = 0x0000e9ec0000e9ec; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ff00ff0120; ++ *((unsigned long *)&__m256i_result0) = 0x0000e9ec0000e9ec; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffdd001dffe00020; ++ *((unsigned long *)&__m256i_op02) = 0xffdd001dffe00031; ++ *((unsigned long *)&__m256i_op01) = 0xffdd001dffe00020; ++ *((unsigned long *)&__m256i_op00) = 0xffdd001dffe00031; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x3ff73ff83ff73ff8; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x3ff73ff83ff73ff8; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op02) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op01) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op00) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0003000300030003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result3) = 0x0600060000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0600060000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0001fffe00010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_result2) = 0x000000000007fff8; ++ *((unsigned long *)&__m256i_result1) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_result0) = 0x000000000007fff8; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op02) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_op01) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op00) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1e0000001e002000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1e0000001e002000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff3225; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff3225; ++ *((unsigned long *)&__m256i_op13) = 0x2221201f1e1d1c1b; ++ *((unsigned long *)&__m256i_op12) = 0x1a19181716151413; ++ *((unsigned long *)&__m256i_op11) = 0x2221201f1e1d1c1b; ++ *((unsigned long *)&__m256i_op10) = 0x1a19181716151413; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000004442403; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000004442403; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x63); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fef0000ffff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fef0000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0xde00fe0000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000fe010000fe01; ++ *((unsigned long *)&__m256i_result1) = 0xde00fe0000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000fe010000fe01; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00fe00ff00fe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000007070707; ++ *((unsigned long *)&__m256i_result2) = 0x00ff00ff07070707; ++ *((unsigned long *)&__m256i_result1) = 0x0000000007070707; ++ *((unsigned long *)&__m256i_result0) = 0x00ff00ff07070707; ++ __m256i_out = __lasx_xvsrlni_b_h (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op01) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x03ff000003ff03ff; ++ *((unsigned long *)&__m256i_result2) = 0x03ff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x03ff000003ff03ff; ++ *((unsigned long *)&__m256i_result0) = 0x03ff000000000000; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_b_h (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_result2) = 0x0007ffff0007ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000700000007; ++ *((unsigned long *)&__m256i_result0) = 0x0007ffff0007ffff; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x66); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000e000e; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000e0000000e00; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfc003802fc000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x03802fc000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x03802fc000000000; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x5a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x080808000828082f; ++ *((unsigned long *)&__m256i_op02) = 0x0808080008280820; ++ *((unsigned long *)&__m256i_op01) = 0x080808000828082f; ++ *((unsigned long *)&__m256i_op00) = 0x0808080008280820; ++ *((unsigned long *)&__m256i_op13) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op12) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_op11) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op10) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_result3) = 0x00828082f0808080; ++ *((unsigned long *)&__m256i_result2) = 0xf18181818132feea; ++ *((unsigned long *)&__m256i_result1) = 0x00828082f0808080; ++ *((unsigned long *)&__m256i_result0) = 0xf18181818132feea; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x24); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op01) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_w_d (__m256i_op0, __m256i_op1, 0x39); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x43); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe01fe01fc01fc01; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op01) = 0xfe01fe01fc01fc01; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfc01000000003fc0; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfc01000000003fc0; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000001fff0; ++ *((unsigned long *)&__m256i_op12) = 0x0000feff0001ffb8; ++ *((unsigned long *)&__m256i_op11) = 0x000000000001fff0; ++ *((unsigned long *)&__m256i_op10) = 0x0000feff0001ffb8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_h_w (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000126000200; ++ *((unsigned long *)&__m256i_op02) = 0x2555205ea7bc4020; ++ *((unsigned long *)&__m256i_op01) = 0x0000000126000200; ++ *((unsigned long *)&__m256i_op00) = 0x2555205ea7bc4020; ++ *((unsigned long *)&__m256i_op13) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op12) = 0x10ffffff10000006; ++ *((unsigned long *)&__m256i_op11) = 0x0fffffff10000006; ++ *((unsigned long *)&__m256i_op10) = 0x10ffffff10000006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000004980008; ++ *((unsigned long *)&__m256i_result2) = 0x003ffffffc400000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000004980008; ++ *((unsigned long *)&__m256i_result0) = 0x003ffffffc400000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x46); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00f0000000f00010; ++ *((unsigned long *)&__m256i_op02) = 0xfff0ff00fff0ff10; ++ *((unsigned long *)&__m256i_op01) = 0x00f0000000f00010; ++ *((unsigned long *)&__m256i_op00) = 0xfff0ff00fff0ff10; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0087ff87f807ff87; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0087ff87f807ff87; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x68); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_b_h (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x50); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op02) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000050005; ++ *((unsigned long *)&__m256i_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op13) = 0xf007fe76f008fe19; ++ *((unsigned long *)&__m256i_op12) = 0xf08aff01f07cc291; ++ *((unsigned long *)&__m256i_op11) = 0xf007fe76f008fe19; ++ *((unsigned long *)&__m256i_op10) = 0xf08aff01f07cc291; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000001400; ++ *((unsigned long *)&__m256i_result2) = 0x0000000003c01ff9; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000003c01ff9; ++ __m256i_out = __lasx_xvsrlni_d_q (__m256i_op0, __m256i_op1, 0x66); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlr.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlr.c +new file mode 100644 +index 000000000..22e62a3e7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlr.c +@@ -0,0 +1,515 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op00) = 0x40d74f979f99419f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x40d74f979f99419f; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff8080000004000; ++ *((unsigned long *)&__m256i_op02) = 0x0000080000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff8080000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000200000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000000; ++ __m256i_out = __lasx_xvsrlr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfff0000000000080; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7ff0000000000000; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvsrlr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001020202; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001020202; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_op12) = 0x00003ddd80007bbb; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000002222; ++ *((unsigned long *)&__m256i_op10) = 0x00003ddd80007bbb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffff800000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff800000000000; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_op02) = 0x007f007f0081007f; ++ *((unsigned long *)&__m256i_op01) = 0x009f00f8007e00f0; ++ *((unsigned long *)&__m256i_op00) = 0x007f007f0081007f; ++ *((unsigned long *)&__m256i_op13) = 0x0ea85f60984a8555; ++ *((unsigned long *)&__m256i_op12) = 0x00a21ef3246995f3; ++ *((unsigned long *)&__m256i_op11) = 0x1189ce8000fa14ed; ++ *((unsigned long *)&__m256i_op10) = 0x0e459089665f40f3; ++ *((unsigned long *)&__m256i_result3) = 0x000100f800000008; ++ *((unsigned long *)&__m256i_result2) = 0x0020001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x000000f800000000; ++ *((unsigned long *)&__m256i_result0) = 0x0004000000000010; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op02) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op01) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_op00) = 0x00003fc00000428a; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0xffffc040ffffc09d; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op01) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op13) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op11) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000008000; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f7f000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x7f7f000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100010001; ++ *((unsigned long *)&__m256i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100010001; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x80000000ff800000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7c00000880008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0100000001000100; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0100000001000100; ++ __m256i_out = __lasx_xvsrlr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000064; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000064; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000008; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffff80; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffff80; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000430207f944; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000038000000268; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000038000000268; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op01) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff010ff0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffff010ff0; ++ *((unsigned long *)&__m256i_result3) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000201; ++ *((unsigned long *)&__m256i_result1) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000201; ++ __m256i_out = __lasx_xvsrlr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op12) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op10) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff01fb0408; ++ *((unsigned long *)&__m256i_op02) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff01fb0408; ++ *((unsigned long *)&__m256i_op00) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result2) = 0xf2b180c9fc1fefdc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_result0) = 0xf2b180c9fc1fefdc; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000080; ++ *((unsigned long *)&__m256i_result3) = 0xff1cff1cff1c3fc7; ++ *((unsigned long *)&__m256i_result2) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_result1) = 0xff1cff1cff1c3fc7; ++ *((unsigned long *)&__m256i_result0) = 0xff1cff1cff1cff1c; ++ __m256i_out = __lasx_xvsrlr_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_op02) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_op01) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_op00) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_op13) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_op12) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_op11) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_op10) = 0x6b6b6b6b6b6b6b6b; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000d6d6d; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000d6d6d; ++ __m256i_out = __lasx_xvsrlr_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff01ff01ff01f010; ++ *((unsigned long *)&__m256i_op12) = 0xff01ff01ff01f010; ++ *((unsigned long *)&__m256i_op11) = 0xff01ff01ff01f010; ++ *((unsigned long *)&__m256i_op10) = 0xff01ff01ff01f010; ++ *((unsigned long *)&__m256i_result3) = 0x000078780000f0f1; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000078780000f0f1; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlr_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffc00040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffc00040; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op12) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0x04f104f104f504ed; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1080108010060002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1080108010060002; ++ __m256i_out = __lasx_xvsrlr_b (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlri.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlri.c +new file mode 100644 +index 000000000..71f770aff +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlri.c +@@ -0,0 +1,416 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x33); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001000000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x28); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000505; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff0002fffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xffff0002ff7e8286; ++ *((unsigned long *)&__m256i_op01) = 0xffff0002fffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xffff0002ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0202000002020202; ++ *((unsigned long *)&__m256i_result2) = 0x0202000002010101; ++ *((unsigned long *)&__m256i_result1) = 0x0202000002020202; ++ *((unsigned long *)&__m256i_result0) = 0x0202000002020000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op02) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op01) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op00) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_result3) = 0x0703030307030203; ++ *((unsigned long *)&__m256i_result2) = 0x0703030307030203; ++ *((unsigned long *)&__m256i_result1) = 0x0703030307030203; ++ *((unsigned long *)&__m256i_result0) = 0x0703030307030203; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00003f3fc6c68787; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00003f3f87870000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003f3fc6c68787; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003f3f87870000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010183f95466; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x01010101d58efe94; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000101000083f95; ++ *((unsigned long *)&__m256i_result2) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_result1) = 0x00001010000d58f0; ++ *((unsigned long *)&__m256i_result0) = 0x0000101000001010; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_result2) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_result1) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_result0) = 0x0010002000100020; ++ __m256i_out = __lasx_xvsrlri_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result2) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_result1) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result0) = 0x0020000000200000; ++ __m256i_out = __lasx_xvsrlri_h (__m256i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000040000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000040000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000020000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000020000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000e000e000e000e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x39); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000040000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000040000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000040000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000040000000000; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op02) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_op01) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_op00) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_result3) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_result2) = 0x132feea900000000; ++ *((unsigned long *)&__m256i_result1) = 0x04e8296f18181818; ++ *((unsigned long *)&__m256i_result0) = 0x132feea900000000; ++ __m256i_out = __lasx_xvsrlri_h (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000038000000268; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000038000000268; ++ *((unsigned long *)&__m256i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x000001200000011a; ++ *((unsigned long *)&__m256i_result2) = 0x2040204020402040; ++ *((unsigned long *)&__m256i_result1) = 0x000001200000011a; ++ *((unsigned long *)&__m256i_result0) = 0x2040204020402040; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_op02) = 0xff81001dff9d003b; ++ *((unsigned long *)&__m256i_op01) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_op00) = 0xff81001dff9d003b; ++ *((unsigned long *)&__m256i_result3) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_w (__m256i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffa003e; ++ *((unsigned long *)&__m256i_op02) = 0x00000000fffb009c; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fffa003e; ++ *((unsigned long *)&__m256i_op00) = 0x00000000fffb009c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvsrlri_d (__m256i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result1) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000001; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0020004000400040; ++ *((unsigned long *)&__m256i_result2) = 0x0020004000400040; ++ *((unsigned long *)&__m256i_result1) = 0x0020004000400040; ++ *((unsigned long *)&__m256i_result0) = 0x0020004000400040; ++ __m256i_out = __lasx_xvsrlri_h (__m256i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000800000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffbfffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffbfffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_result3) = 0x0102020202010202; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0102020202010202; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvsrlri_b (__m256i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000006; ++ *((unsigned long *)&__m256i_op02) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000006; ++ *((unsigned long *)&__m256i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0008000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0008000000000000; ++ __m256i_out = __lasx_xvsrlri_h (__m256i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrn.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrn.c +new file mode 100644 +index 000000000..cbc1de371 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrn.c +@@ -0,0 +1,410 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffff328dfff; ++ *((unsigned long *)&__m256i_op00) = 0x6651bfff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0202020201010000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000050005; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000505; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op12) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op12) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_op11) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op10) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000000000000; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000001a00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_op02) = 0xff820002ff820002; ++ *((unsigned long *)&__m256i_op01) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_op00) = 0xff820002ff820002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00020002ff820002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00020002ff820002; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00020421d7d41124; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00020421d7d41124; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff000200000000; ++ *((unsigned long *)&__m256i_op01) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff000200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff020000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff020000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001fe01fe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000ff0100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001fe01fe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000ff0100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000000007c8; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000007c8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01fe01fe0000ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01fe01fe0000ff01; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op02) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op01) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op00) = 0xf9f9f9f9f9f9f9f9; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xf9f9f9f900000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xf9f9f9f900000002; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_op11) = 0x0000ff0100ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000004843ffdff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00043fff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00043fff00000000; ++ __m256i_out = __lasx_xvsrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xff1cff1b00e300e4; ++ *((unsigned long *)&__m256i_op12) = 0xff1cff1b00e300e4; ++ *((unsigned long *)&__m256i_op11) = 0xff1cff1b00e300e4; ++ *((unsigned long *)&__m256i_op10) = 0xff1cff1b00e30100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x002000000020ffff; ++ __m256i_out = __lasx_xvsrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffdbff980038ffaf; ++ *((unsigned long *)&__m256i_op02) = 0xffafffe80004fff1; ++ *((unsigned long *)&__m256i_op01) = 0xffdbff980038ffaf; ++ *((unsigned long *)&__m256i_op00) = 0xffafffe80004fff1; ++ *((unsigned long *)&__m256i_op13) = 0x0000020202020202; ++ *((unsigned long *)&__m256i_op12) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000020202020202; ++ *((unsigned long *)&__m256i_op10) = 0x0101000000010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000e3fec0004fff1; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000e3fec0004fff1; ++ __m256i_out = __lasx_xvsrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrni.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrni.c +new file mode 100644 +index 000000000..8fc7a0029 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvsrlrni.c +@@ -0,0 +1,455 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x7a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000000; ++ *((unsigned long *)&__m256i_op00) = 0x0100010001000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000808000008080; ++ *((unsigned long *)&__m256i_op02) = 0x0000808000008081; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000081; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x68); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000002a5429; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000801380f380fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000801380f300fb; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000007f3a40; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x42); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x56); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xf0000000f0000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xf0000000f0000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_h_w (__m256i_op0, __m256i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0404040404040404; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op02) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op00) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op12) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op10) = 0x817f11ed81800ff0; ++ *((unsigned long *)&__m256i_result3) = 0x00000004fc480040; ++ *((unsigned long *)&__m256i_result2) = 0x00000004fc480040; ++ *((unsigned long *)&__m256i_result1) = 0x00000004fc480040; ++ *((unsigned long *)&__m256i_result0) = 0x00000004fc480040; ++ __m256i_out = __lasx_xvsrlrni_h_w (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0004000404040404; ++ *((unsigned long *)&__m256i_result2) = 0x0000000400000004; ++ *((unsigned long *)&__m256i_result1) = 0x0004000400000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000400000004; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_h_w (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x80208020c22080a7; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x80208020c22080a7; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdf80ff20df80ff20; ++ *((unsigned long *)&__m256i_op12) = 0xdfc2ff20df80ffa7; ++ *((unsigned long *)&__m256i_op11) = 0xdf80ff20df80ff20; ++ *((unsigned long *)&__m256i_op10) = 0xdfc2ff20df80ffa7; ++ *((unsigned long *)&__m256i_result3) = 0x0000840100000000; ++ *((unsigned long *)&__m256i_result2) = 0xbffebffec0febfff; ++ *((unsigned long *)&__m256i_result1) = 0x0000840100000000; ++ *((unsigned long *)&__m256i_result0) = 0xbffebffec0febfff; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffc0c0ffffbfc0; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffc0c0ffffbfc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00003f3f0000400d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00003f3f0000400d; ++ *((unsigned long *)&__m256i_result3) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x44); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x1000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffe00000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfc00000000000048; ++ *((unsigned long *)&__m256i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfc00000000000048; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xbfffa004fffd8000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xbfffa004fffd8000; ++ *((unsigned long *)&__m256i_result3) = 0x00003f0000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00002fffe8013fff; ++ *((unsigned long *)&__m256i_result1) = 0x00003f0000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00002fffe8013fff; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000080800000808; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000101000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000101000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op02) = 0xff00010001000100; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op00) = 0xff00010001000100; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_result2) = 0x0000004000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_result0) = 0x0000004000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x5a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00b2fe28e4420609; ++ *((unsigned long *)&__m256i_op02) = 0x028da7fe15020000; ++ *((unsigned long *)&__m256i_op01) = 0x00b2fe28e4420609; ++ *((unsigned long *)&__m256i_op00) = 0x028da7fe15020000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000598; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000598; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0x6d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000800000010; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000800000010; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000002000000; ++ __m256i_out = __lasx_xvsrlrni_d_q (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000003ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0001ffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000003ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0001ffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_w_d (__m256i_op0, __m256i_op1, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0040000000000000; ++ __m256i_out = __lasx_xvsrlrni_w_d (__m256i_op0, __m256i_op1, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_op02) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_op01) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_op00) = 0x0000001200000012; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0fff0fff0fc00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0fff0fff0fc00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000f880f87e; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000f880f87e; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000008000; ++ __m256i_out = __lasx_xvsrlrni_h_w (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000081220000812c; ++ *((unsigned long *)&__m256i_op02) = 0x0000812000008120; ++ *((unsigned long *)&__m256i_op01) = 0x000081220000812c; ++ *((unsigned long *)&__m256i_op00) = 0x0000812000008120; ++ *((unsigned long *)&__m256i_op13) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op12) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op11) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op10) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result3) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result2) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result1) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_result0) = 0xfefefefefefefefe; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvsrlrni_b_h (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvssran-xvssrani-.patch
Added
@@ -0,0 +1,4258 @@ +From 445ae07ab55a647f7aec97c2334fb276a44f2af1 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Wed, 13 Sep 2023 12:37:41 +0800 +Subject: PATCH 121/124 LoongArch: Add tests for ASX vector + xvssran/xvssrani/xvssrarn/xvssrarni instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvssran.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvssrani.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvssrarn.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvssrarni.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvssran.c | 905 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvssrani.c | 1235 +++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvssrarn.c | 905 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvssrarni.c | 1160 ++++++++++++++++ + 4 files changed, 4205 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssran.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrani.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarni.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssran.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssran.c +new file mode 100644 +index 000000000..fdb0c25f1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssran.c +@@ -0,0 +1,905 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00007ffe81fdfe03; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7ffe800000000000; ++ __m256i_out = __lasx_xvssran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_op02) = 0xffffffef000004ea; ++ *((unsigned long *)&__m256i_op01) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_op00) = 0xffffffefffffffef; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_op02) = 0x000607f700000001; ++ *((unsigned long *)&__m256i_op01) = 0x1717171717171717; ++ *((unsigned long *)&__m256i_op00) = 0x000607f700000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffe81; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00f9f90079f9f9f9; ++ *((unsigned long *)&__m256i_op12) = 0x79f9f9f900000000; ++ *((unsigned long *)&__m256i_op11) = 0x00f9f90079f9f9f9; ++ *((unsigned long *)&__m256i_op10) = 0x79f9f9f900000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007f7f; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000007f7f; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f007f78; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000033007e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000021; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007f7f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007f7f00007fff; ++ __m256i_out = __lasx_xvssran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op13) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000080; ++ __m256i_out = __lasx_xvssran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff00000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000002aaad555; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000002aaad555; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007fff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff00000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op02) = 0xffc00000ffc0ffc0; ++ *((unsigned long *)&__m256i_op01) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m256i_op00) = 0xffc00000ffc0ffc0; ++ *((unsigned long *)&__m256i_op13) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op12) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_op11) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op10) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffcfee0fe00ffe0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffcfee0fe00ffe0; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000001fff9fff8; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fff9fff8; ++ *((unsigned long *)&__m256i_op01) = 0x00000001fff9fff8; ++ *((unsigned long *)&__m256i_op00) = 0x00000001fff9fff8; ++ *((unsigned long *)&__m256i_op13) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op12) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op11) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_op10) = 0xe1616161e1614e60; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0xfffffff900000003; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0xfffffff900000003; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff0000; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000100000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000100000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00000000; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xff2400000000ff00; ++ *((unsigned long *)&__m256i_op12) = 0xfffeffe4fffeff00; ++ *((unsigned long *)&__m256i_op11) = 0xff6400000000ff00; ++ *((unsigned long *)&__m256i_op10) = 0xfffeff66fffeff00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000100da000100fd; ++ *((unsigned long *)&__m256i_op12) = 0x0001ffe20001fefd; ++ *((unsigned long *)&__m256i_op11) = 0x0001009a000100fd; ++ *((unsigned long *)&__m256i_op10) = 0x0001ff640001fefd; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fe0100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fe0100000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op02) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_op01) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op00) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_op13) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op12) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op11) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_op10) = 0xc2c2c2c2c2c2c2c2; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op12) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_op11) = 0xdbcbdbcbecececec; ++ *((unsigned long *)&__m256i_op10) = 0xdbcbdbcb0000dbcb; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_op02) = 0x000016000000480d; ++ *((unsigned long *)&__m256i_op01) = 0x0000226200005111; ++ *((unsigned long *)&__m256i_op00) = 0x000016000000480d; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x1131288800000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x1131288800000002; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op02) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op00) = 0x0101010200000000; ++ *((unsigned long *)&__m256i_op13) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op12) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op11) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_op10) = 0x0a0a0a0a7f0a0a0a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffff040000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op11) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_op02) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_op01) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_op00) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007f3f7f007f1f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007f3f7f007f1f; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_op12) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_op11) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_op10) = 0x007f8080007f007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff00000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000077fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000000007ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8d8d72728d8d7272; ++ *((unsigned long *)&__m256i_op02) = 0x8d8d72728d8d8d8d; ++ *((unsigned long *)&__m256i_op01) = 0x8d8d72728d8d7272; ++ *((unsigned long *)&__m256i_op00) = 0x8d8d72728d8d8d8d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000001010800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001010800; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fffff800; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001010800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001010800; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000430207f944; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffff0008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffff0008; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfdfdfdfdfdfdfdfd; ++ *((unsigned long *)&__m256i_op02) = 0xe27fe2821d226278; ++ *((unsigned long *)&__m256i_op01) = 0xfdfdfdfdfdfdfdfd; ++ *((unsigned long *)&__m256i_op00) = 0xe27fe2821d226278; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op12) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op11) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_op10) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000000e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000000e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000000d; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010001; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080ff0080; ++ *((unsigned long *)&__m256i_op01) = 0x8000400080ffc080; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080ff0080; ++ *((unsigned long *)&__m256i_op13) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op11) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00ff000000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00ff000000000080; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000007f807f80; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007f807f80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000007f7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000007f7f; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000001fff0; ++ *((unsigned long *)&__m256i_op12) = 0x0000feff0001ffb8; ++ *((unsigned long *)&__m256i_op11) = 0x000000000001fff0; ++ *((unsigned long *)&__m256i_op10) = 0x0000feff0001ffb8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff1cff18; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffff1cff1c; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff1cff18; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssran_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op02) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op01) = 0x0000000600000006; ++ *((unsigned long *)&__m256i_op00) = 0x000000070002000a; ++ *((unsigned long *)&__m256i_op13) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x001fffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op02) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op01) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op00) = 0xffffffe7ffffffe7; ++ *((unsigned long *)&__m256i_op13) = 0xbf3ffffffffeffed; ++ *((unsigned long *)&__m256i_op12) = 0xbf3ffffffffeffed; ++ *((unsigned long *)&__m256i_op11) = 0xbf3ffffffffeffed; ++ *((unsigned long *)&__m256i_op10) = 0xbf3ffffffffeffed; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe013fcf2e015fc38; ++ *((unsigned long *)&__m256i_op02) = 0xe013fd00dff78420; ++ *((unsigned long *)&__m256i_op01) = 0xe013fcf2e015fc38; ++ *((unsigned long *)&__m256i_op00) = 0xe013fd00dff78420; ++ *((unsigned long *)&__m256i_op13) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op12) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_op11) = 0x0005000500050005; ++ *((unsigned long *)&__m256i_op10) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssran_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op13) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_op12) = 0x8768876887688769; ++ *((unsigned long *)&__m256i_op11) = 0x8282828282828282; ++ *((unsigned long *)&__m256i_op10) = 0x8768876887688769; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000003fffc0; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000003fffc0; ++ __m256i_out = __lasx_xvssran_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrani.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrani.c +new file mode 100644 +index 000000000..dd3c2c6f6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrani.c +@@ -0,0 +1,1235 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7f057f0b7f5b007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000007f007f5; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000001fc000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000c475ceb40000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fb0819280000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x074132a240000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000003a0200; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000000c9; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op01) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00007fff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00007fff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x37); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff8001; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffff8001; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffff0ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffff0ffff0000; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000080008000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000080008000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001ffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001ffffff; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x73); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0100010001000000; ++ *((unsigned long *)&__m256i_op10) = 0x0100010001000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0004000400040004; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff0000000000080; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op01) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000f0000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x1fe01e0000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x22); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x6b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0xce7ffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xce7ffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0x6300000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff39ffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff39ffffff; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x5e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op02) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op00) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op13) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_op12) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_op11) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_op10) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op02) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op01) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op00) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fe8001b72e0001; ++ *((unsigned long *)&__m256i_op02) = 0xb72e8001b72eaf12; ++ *((unsigned long *)&__m256i_op01) = 0x01fe000247639d9c; ++ *((unsigned long *)&__m256i_op00) = 0xb5308001b72eaf12; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x26); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000010000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000c40086; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00001fff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00001fff; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x38f7414938f7882f; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x38f7414938f78830; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000801380f380fe; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000801380f300fb; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000008; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0303030303020000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0303030303020000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0x31); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000007; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x4d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x59); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op02) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xd04752cdd5543b56; ++ *((unsigned long *)&__m256i_op02) = 0x6906e68064f3d78b; ++ *((unsigned long *)&__m256i_op01) = 0xd04752cdd5543b56; ++ *((unsigned long *)&__m256i_op00) = 0x6906e68064f3d78b; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000004560420; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ff1100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000004560420; ++ *((unsigned long *)&__m256i_result3) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256i_result2) = 0x00000fff00004542; ++ *((unsigned long *)&__m256i_result1) = 0x00ff00ffff00ff00; ++ *((unsigned long *)&__m256i_result0) = 0x00000fff00004542; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op02) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_op01) = 0xdf00000052a00000; ++ *((unsigned long *)&__m256i_op00) = 0x5b7f00ff5b7f00ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00c0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0040000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x00000000c0000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000040000000; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffffe02; ++ *((unsigned long *)&__m256i_op02) = 0x00000300000005fe; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffff02; ++ *((unsigned long *)&__m256i_op00) = 0x00000300000005fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x0007fd00000f02ff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001fffeff; ++ *((unsigned long *)&__m256i_op10) = 0xff00fe00feff02ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ffffffff00; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000007f; ++ *((unsigned long *)&__m256i_op13) = 0x0000002000000018; ++ *((unsigned long *)&__m256i_op12) = 0x0000002000000019; ++ *((unsigned long *)&__m256i_op11) = 0x000000200000001e; ++ *((unsigned long *)&__m256i_op10) = 0x0000002000000019; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0004000000030000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000400000003c000; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x33); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x009c3e201e39e7e3; ++ *((unsigned long *)&__m256i_op02) = 0x87c1135043408bba; ++ *((unsigned long *)&__m256i_op01) = 0x009c3e201e39e7e3; ++ *((unsigned long *)&__m256i_op00) = 0x87c1135043408bba; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256i_op02) = 0x7f7f7f5c8f374980; ++ *((unsigned long *)&__m256i_op01) = 0x0001b0b1b4b5dd9f; ++ *((unsigned long *)&__m256i_op00) = 0x7f7f7f5c8f374980; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op10) = 0xd0d8eecf383fdf0d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100007f7f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100007f7f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x39); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007c7fff00007fff; ++ *((unsigned long *)&__m256i_op02) = 0x00817fff00810000; ++ *((unsigned long *)&__m256i_op01) = 0x007c7fff00007fff; ++ *((unsigned long *)&__m256i_op00) = 0x00817fff00810000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x7c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x4000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000457d; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000b03f; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000457d; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000b03f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x2000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x2000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op02) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0f000f000f000f00; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0f000f000f000f00; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op12) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op11) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op10) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007fc0083fc7c007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007fc0083fc7c007; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x42); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00067fff00047fff; ++ *((unsigned long *)&__m256i_op02) = 0x00027fff000080fe; ++ *((unsigned long *)&__m256i_op01) = 0x00067fff00047fff; ++ *((unsigned long *)&__m256i_op00) = 0x00027fff000080fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x067f047f027f0080; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x067f047f027f0080; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_op13) = 0x0af57272788754ab; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000005e80; ++ *((unsigned long *)&__m256i_op11) = 0x0af57272788754ab; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000005e80; ++ *((unsigned long *)&__m256i_result3) = 0x00000000000f0f0f; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f0000007f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000000f0f0f; ++ *((unsigned long *)&__m256i_result0) = 0x7f7f7f7f0000007f; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op02) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op00) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_op12) = 0x0000004000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000040004000; ++ *((unsigned long *)&__m256i_op10) = 0x0000004000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0001000100000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0001000100000000; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x4b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op12) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_op11) = 0x0004000f00100003; ++ *((unsigned long *)&__m256i_op10) = 0x000400030010000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0400100004001000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0400100004001000; ++ __m256i_out = __lasx_xvssrani_hu_w (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256i_op02) = 0x408480007fff0000; ++ *((unsigned long *)&__m256i_op01) = 0x3eab77367fff4848; ++ *((unsigned long *)&__m256i_op00) = 0x408480007fff0000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000700000008; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000700000008; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x55); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xc07f8000c07f8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xc07f8000c07f8000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0x00000000fff01fe0; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000fff01fe0; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fe96fe95; ++ *((unsigned long *)&__m256i_op02) = 0x6afc01000001ff00; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fe96fe95; ++ *((unsigned long *)&__m256i_op00) = 0x6afc01000001ff00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x000000010000ff00; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x000000010000ff00; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x7e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000040404000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000040404000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000404; ++ *((unsigned long *)&__m256i_result1) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000404; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_op02) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_op01) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_op00) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_op13) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_op12) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_op11) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_op10) = 0x0404000004040000; ++ *((unsigned long *)&__m256i_result3) = 0x4000400040004000; ++ *((unsigned long *)&__m256i_result2) = 0x4000400040004000; ++ *((unsigned long *)&__m256i_result1) = 0x4000400040004000; ++ *((unsigned long *)&__m256i_result0) = 0x4000400040004000; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000020202000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000020202000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007f433c78; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000001ff1; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000001ff1; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x53); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x03fbfffc03fc07fc; ++ *((unsigned long *)&__m256i_op12) = 0x8000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x03fbfffc03fc07fc; ++ *((unsigned long *)&__m256i_op10) = 0x8000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff80000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff80000000; ++ __m256i_out = __lasx_xvssrani_w_d (__m256i_op0, __m256i_op1, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op02) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff003fffc0; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x00000000003fffc0; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffc00fffffc00; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffc00fffffc00; ++ *((unsigned long *)&__m256i_op13) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op12) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256i_op11) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op10) = 0xff00ff007f007f00; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result2) = 0xc03fc03fc03fc03f; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result0) = 0xc03fc03fc03fc03f; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000000ff; ++ __m256i_out = __lasx_xvssrani_b_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ff80; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_wu_d (__m256i_op0, __m256i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x6c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrani_h_w (__m256i_op0, __m256i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000700000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000700000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000005; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000005; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x60); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op02) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op01) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op00) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op13) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op12) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_op11) = 0x0004000400040004; ++ *((unsigned long *)&__m256i_op10) = 0x0004000500040005; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrani_du_q (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fff80007fff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrani_bu_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffff0000fffd0004; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op00) = 0xffff0000fffd0004; ++ *((unsigned long *)&__m256i_op13) = 0xffff0000fffd0004; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0002fffd; ++ *((unsigned long *)&__m256i_op10) = 0xffff0000fffd0004; ++ *((unsigned long *)&__m256i_result3) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000000f; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000000f; ++ __m256i_out = __lasx_xvssrani_d_q (__m256i_op0, __m256i_op1, 0x6c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarn.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarn.c +new file mode 100644 +index 000000000..7848ddd41 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarn.c +@@ -0,0 +1,905 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op12) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op11) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op10) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff0000ffff0000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff80000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvssrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000100da000100fd; ++ *((unsigned long *)&__m256i_op02) = 0x0001ffe20001fefd; ++ *((unsigned long *)&__m256i_op01) = 0x0001009a000100fd; ++ *((unsigned long *)&__m256i_op00) = 0x0001ff640001fefd; ++ *((unsigned long *)&__m256i_op13) = 0x000100da000100fd; ++ *((unsigned long *)&__m256i_op12) = 0x0001ffe20001fefd; ++ *((unsigned long *)&__m256i_op11) = 0x0001009a000100fd; ++ *((unsigned long *)&__m256i_op10) = 0x0001ff640001fefd; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007ff90000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000001ff60000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000001; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_op12) = 0x0000001b00fd0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_op10) = 0x0000001b00fd0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op02) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op01) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op00) = 0xff00ffffff00ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256i_op01) = 0x0080000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00010002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op02) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_op01) = 0x00c200c200c200c2; ++ *((unsigned long *)&__m256i_op00) = 0x00c200c200c200bb; ++ *((unsigned long *)&__m256i_op13) = 0xffffc2c2ffffc2c2; ++ *((unsigned long *)&__m256i_op12) = 0xffffc2c2ffffc2c2; ++ *((unsigned long *)&__m256i_op11) = 0xffffc2c2ffffc2c2; ++ *((unsigned long *)&__m256i_op10) = 0xffffc2c2ffffc2c2; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x003100310031002f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x003100310031002f; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffefffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op02) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op01) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op13) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op12) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op11) = 0xfffe0001fffe0003; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001000000010000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001000000000002; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffff6f20; ++ *((unsigned long *)&__m256i_op12) = 0x0000781e0000f221; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff6f20; ++ *((unsigned long *)&__m256i_op10) = 0x0000781e0000f221; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000fffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op02) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_op01) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op00) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_op13) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op12) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_op11) = 0xbf00bf00bf00bf00; ++ *((unsigned long *)&__m256i_op10) = 0xbf84bf00bf00bf0e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x00007f7f80007fa3; ++ *((unsigned long *)&__m256i_op12) = 0x000000007f670000; ++ *((unsigned long *)&__m256i_op11) = 0x00007f7f80007fa3; ++ *((unsigned long *)&__m256i_op10) = 0x000000007f670000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000008; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000008; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op12) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op11) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_op10) = 0xfff1fff1fff1fff1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffff000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffff000; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffff000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffff000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffff0001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_op02) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_op01) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_op00) = 0x000408080c111414; ++ *((unsigned long *)&__m256i_op13) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_op12) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_op11) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_op10) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff88ff88; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op02) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op00) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000800400010006d; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000800400010006d; ++ __m256i_out = __lasx_xvssrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0200000002000000; ++ *((unsigned long *)&__m256i_op02) = 0x02000000fdffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0200000002000000; ++ *((unsigned long *)&__m256i_op00) = 0x02000000fdffffff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_op11) = 0x00000000000000b7; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffefff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000004ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000004ffffffff; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x3fd1000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff000000ff000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff000000ff000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffb6811fffff80; ++ *((unsigned long *)&__m256i_op02) = 0xffff97c120000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffb6811fffff80; ++ *((unsigned long *)&__m256i_op00) = 0xffff97c120000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op12) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op11) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_op10) = 0x00000001fffffff9; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xdb410010cbe10010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xdb410010cbe10010; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000019ffdf403; ++ *((unsigned long *)&__m256i_op12) = 0x000000011ffd97c3; ++ *((unsigned long *)&__m256i_op11) = 0x000000019ffdf403; ++ *((unsigned long *)&__m256i_op10) = 0x000000011ffd97c3; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x002000000020ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000004000000040; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000004000000040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x1a1a1a2c1a1a1a2c; ++ *((unsigned long *)&__m256i_op12) = 0x1a1a1a2c1a1a1a2c; ++ *((unsigned long *)&__m256i_op11) = 0x1a1a1a2c1a1a1a2c; ++ *((unsigned long *)&__m256i_op10) = 0x1a1a1a2c1a1a1a2c; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x3838383838383838; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffdfffffe00; ++ *((unsigned long *)&__m256i_op01) = 0x3838383838383838; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffdfffffe00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00000000; ++ __m256i_out = __lasx_xvssrarn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000020002000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000020002000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffbffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_op11) = 0xffbffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_op13) = 0xc03b000200020002; ++ *((unsigned long *)&__m256i_op12) = 0xc03b000200020002; ++ *((unsigned long *)&__m256i_op11) = 0xc03b000200020002; ++ *((unsigned long *)&__m256i_op10) = 0xc03b000200020002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000001ec020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000001ec020; ++ __m256i_out = __lasx_xvssrarn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarni.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarni.c +new file mode 100644 +index 000000000..b1c16baf4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrarni.c +@@ -0,0 +1,1160 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffc00; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000020000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000020000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_du_q (__m256i_op0, __m256i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000f20; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00000000000009f0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00001f41ffffbf00; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000400000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000010000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000010000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000010000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000010000000; ++ __m256i_out = __lasx_xvssrarni_b_h (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op12) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m256i_op10) = 0x0000000f0000000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000100; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x5d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf5f5bfbaf5f5bfbe; ++ *((unsigned long *)&__m256i_op02) = 0xf5f0bfb8f5d8bfe8; ++ *((unsigned long *)&__m256i_op01) = 0xf5f5bfbaf5f5bfbe; ++ *((unsigned long *)&__m256i_op00) = 0xf5f0bfb8f5d8bfe8; ++ *((unsigned long *)&__m256i_op13) = 0xf5f5bfbaf5f5bfbe; ++ *((unsigned long *)&__m256i_op12) = 0xf5f0bfb8f5d8bfe8; ++ *((unsigned long *)&__m256i_op11) = 0xf5f5bfbaf5f5bfbe; ++ *((unsigned long *)&__m256i_op10) = 0xf5f0bfb8f5d8bfe8; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff5f5c; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff5f5c; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x6c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op02) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op01) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op00) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op13) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op12) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op11) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_op10) = 0x005500550055ffab; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fffff6ff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fffff6ff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0a09080706050403; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0a09080706050403; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0003000200000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0003000200000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x8000000080000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000010000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0001010300010102; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000410041; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_bu_h (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000df93f0000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000077843; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000003800000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_bu_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_b_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_du_q (__m256i_op0, __m256i_op1, 0x73); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8001b72e0001b72e; ++ *((unsigned long *)&__m256i_op02) = 0x8001b72eaf12d5f0; ++ *((unsigned long *)&__m256i_op01) = 0x000247639d9cb530; ++ *((unsigned long *)&__m256i_op00) = 0x8001b72eaf12d5f0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffe056fd9d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffceba70; ++ *((unsigned long *)&__m256i_result3) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00150015003a402f; ++ *((unsigned long *)&__m256i_op02) = 0x333568ce26dcd055; ++ *((unsigned long *)&__m256i_op01) = 0x00150015003a402f; ++ *((unsigned long *)&__m256i_op00) = 0x333568ce26dcd055; ++ *((unsigned long *)&__m256i_op13) = 0x0000000007d0d0d0; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000007d0d0d0; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800000098; ++ *((unsigned long *)&__m256i_op02) = 0x000000040000ffca; ++ *((unsigned long *)&__m256i_op01) = 0x0000000800000098; ++ *((unsigned long *)&__m256i_op00) = 0x000000040000ff79; ++ *((unsigned long *)&__m256i_op13) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op12) = 0xff04ff00ff00ff00; ++ *((unsigned long *)&__m256i_op11) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m256i_op10) = 0xff04ff00ff00ff00; ++ *((unsigned long *)&__m256i_result3) = 0x000000008000000a; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x000000008000000a; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_du_q (__m256i_op0, __m256i_op1, 0x44); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000120e120d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000120e120d; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000907; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0016001600160016; ++ *((unsigned long *)&__m256i_op02) = 0x0016001600160016; ++ *((unsigned long *)&__m256i_op01) = 0x0016001600160016; ++ *((unsigned long *)&__m256i_op00) = 0x0016001600160016; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_bu_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_bu_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_op02) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_op01) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_op00) = 0x0010002000100020; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000fffffffe; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000fffffffe; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffe000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffe000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x54); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00030006fa05f20e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00030081bd80f90e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000018; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000018; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_w_d (__m256i_op0, __m256i_op1, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x02407a3c00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0d0cf2f30d0cf2f3; ++ *((unsigned long *)&__m256i_op01) = 0x02407a3c00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0d0cf2f30d0cf2f3; ++ *((unsigned long *)&__m256i_op13) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op12) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_op11) = 0xefdfefdf00000000; ++ *((unsigned long *)&__m256i_op10) = 0xefdfefdfefdfefdf; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op12) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_op11) = 0x0020000f0000000f; ++ *((unsigned long *)&__m256i_op10) = 0x0010000f0000000f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_b_h (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op02) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op01) = 0x00000000f0f0f0f0; ++ *((unsigned long *)&__m256i_op00) = 0xf0f0f0f0f0f0f0f0; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000ff0fff0fff0f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000ff0fff0fff0f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffff70156; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_du_q (__m256i_op0, __m256i_op1, 0x74); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xde00fe0000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000fe010000fe01; ++ *((unsigned long *)&__m256i_op01) = 0xde00fe0000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000fe010000fe01; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_b_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000100010001ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000100010001ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000100010001ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000100010001ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00007ff000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x79); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op02) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000070007000; ++ *((unsigned long *)&__m256i_op00) = 0x7000700070007000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result3) = 0x0e0e0e0e0e0e0e0e; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000e0e0e0e0e0e; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_b_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op12) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_op11) = 0xc848c848c848c848; ++ *((unsigned long *)&__m256i_op10) = 0x8848c848c848c848; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_bu_h (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xa1a1a1a1a1a15e5e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xa1a1a1a1a1a15e5e; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op12) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op11) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op10) = 0xffe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00003fe000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00003fe000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_du_q (__m256i_op0, __m256i_op1, 0x45); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001fffe0001fffa; ++ *((unsigned long *)&__m256i_op12) = 0x0001fffe00018069; ++ *((unsigned long *)&__m256i_op11) = 0x0001fffe0001fffa; ++ *((unsigned long *)&__m256i_op10) = 0x0001fffe00018069; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000002000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000002000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x64); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000004000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000004000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_bu_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_op02) = 0x00e9a80014ff0000; ++ *((unsigned long *)&__m256i_op01) = 0x00b213171dff0606; ++ *((unsigned long *)&__m256i_op00) = 0x00e9a80014ff0000; ++ *((unsigned long *)&__m256i_op13) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xff00000000ffffff; ++ *((unsigned long *)&__m256i_op11) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xff00000000ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000038000000268; ++ *((unsigned long *)&__m256i_op12) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op11) = 0x0000038000000268; ++ *((unsigned long *)&__m256i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001010101; ++ __m256i_out = __lasx_xvssrarni_bu_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0400000004000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000400; ++ *((unsigned long *)&__m256i_result1) = 0x0400000004000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000400; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x5b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0080000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x08000000000000f8; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x08000000000000f8; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0200000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x2000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0200000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x2000000000000000; ++ __m256i_out = __lasx_xvssrarni_wu_d (__m256i_op0, __m256i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000013; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x6a); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x36); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op12) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_op11) = 0x498000804843ffe0; ++ *((unsigned long *)&__m256i_op10) = 0x4980008068400000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrarni_hu_w (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000008; ++ *((unsigned long *)&__m256i_op02) = 0x000000040000001b; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000008; ++ *((unsigned long *)&__m256i_op00) = 0x000000040000001b; ++ *((unsigned long *)&__m256i_op13) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_b_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_op11) = 0x41dffbffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffff00ff800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f80ffffff808000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7f80ffffff808000; ++ __m256i_out = __lasx_xvssrarni_b_h (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000001e00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0002000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrarni_h_w (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000500020002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000700020033; ++ *((unsigned long *)&__m256i_op01) = 0x0000000500020002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000700020033; ++ *((unsigned long *)&__m256i_op13) = 0x0000000500020002; ++ *((unsigned long *)&__m256i_op12) = 0x0000000700020033; ++ *((unsigned long *)&__m256i_op11) = 0x0000000500020002; ++ *((unsigned long *)&__m256i_op10) = 0x0000000700020033; ++ *((unsigned long *)&__m256i_result3) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_result2) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_result1) = 0x1400080008000000; ++ *((unsigned long *)&__m256i_result0) = 0x1400080008000000; ++ __m256i_out = __lasx_xvssrarni_d_q (__m256i_op0, __m256i_op1, 0x26); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000001c; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000001de; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000001c; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000001de; ++ *((unsigned long *)&__m256i_op13) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op11) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000060000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000060000000; ++ __m256i_out = __lasx_xvssrarni_du_q (__m256i_op0, __m256i_op1, 0x44); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00003fea0014734d; ++ *((unsigned long *)&__m256i_op02) = 0x00003fe900140d85; ++ *((unsigned long *)&__m256i_op01) = 0x00003fea0014734d; ++ *((unsigned long *)&__m256i_op00) = 0x00003fe900140d85; ++ *((unsigned long *)&__m256i_op13) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op12) = 0x000000ff0000ff00; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff0000ff00; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrarni_du_q (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-vector-xvssrln-xvssrlni-.patch
Added
@@ -0,0 +1,4123 @@ +From 983fd43b599dd252bc7f869be27bf1677f8eeca7 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Wed, 13 Sep 2023 12:35:41 +0800 +Subject: PATCH 120/124 LoongArch: Add tests for ASX vector + xvssrln/xvssrlni/xvssrlrn/xvssrlrni instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvssrln.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvssrlni.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvssrlrn.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvssrlrni.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvssrln.c | 965 ++++++++++++++ + .../loongarch/vector/lasx/lasx-xvssrlni.c | 1130 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvssrlrn.c | 815 ++++++++++++ + .../loongarch/vector/lasx/lasx-xvssrlrni.c | 1160 +++++++++++++++++ + 4 files changed, 4070 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrln.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlni.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrni.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrln.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrln.c +new file mode 100644 +index 000000000..356eb2182 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrln.c +@@ -0,0 +1,965 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x44bb2cd3a35c2fd0; ++ *((unsigned long *)&__m256i_op00) = 0xca355ba46a95e31c; ++ *((unsigned long *)&__m256i_op13) = 0x000100ab000500a0; ++ *((unsigned long *)&__m256i_op12) = 0x000200b800080124; ++ *((unsigned long *)&__m256i_op11) = 0x0001011b000200aa; ++ *((unsigned long *)&__m256i_op10) = 0x00150118008f0091; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7f057f0b7f5b007f; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000020000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000020000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000007f00; ++ *((unsigned long *)&__m256i_op02) = 0x7fff7ffe7fffeffe; ++ *((unsigned long *)&__m256i_op01) = 0xffffd84900000849; ++ *((unsigned long *)&__m256i_op00) = 0x07fffc670800f086; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000000; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op02) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op01) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op00) = 0x000000017ffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff0ffff0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff0ffff0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000017000000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000017000000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001700080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001700080; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_op02) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_op01) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_op00) = 0x2000200020002000; ++ *((unsigned long *)&__m256i_op13) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffff8c80; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fff0e400; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000005536aaaaac; ++ *((unsigned long *)&__m256i_op02) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op01) = 0x0000005536aaaaac; ++ *((unsigned long *)&__m256i_op00) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op13) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xfff9fffffffbffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffdaaaaffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000060102150101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000060102150101; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfe00000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x1cfd000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xff00000000000000; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000003f00000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000003f0000; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007f7f7f7f0000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op02) = 0x000000000154dc84; ++ *((unsigned long *)&__m256i_op01) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000089; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007fff00007fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff00000089; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfe7fffecfe7fffec; ++ *((unsigned long *)&__m256i_op02) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op01) = 0xfe7fffecfe7fffec; ++ *((unsigned long *)&__m256i_op00) = 0xff80000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000001; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op02) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffff600000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff000009ec; ++ *((unsigned long *)&__m256i_op01) = 0xfffffff600000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff000009ec; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op02) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op01) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op00) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000ff0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrln_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8060000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8060000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00001fff200007ef; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff000000010000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000008000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000003f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff00000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff00000001; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff81ff7dffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op01) = 0xff81ff7dffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff81ff7d; ++ *((unsigned long *)&__m256i_op13) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op12) = 0x7f7f7f7f7f017ffd; ++ *((unsigned long *)&__m256i_op11) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_op10) = 0x7f7f7f7f7f017ffd; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000100000007; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000100000007; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000001; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000007ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000077fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op12) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_op11) = 0x01ff0020ff1f001f; ++ *((unsigned long *)&__m256i_op10) = 0x7fe1ffe0ffe1ffe0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00011ffb0000bee1; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00011ffb0000bee1; ++ *((unsigned long *)&__m256i_op13) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op12) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m256i_op10) = 0xff00000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op02) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_op01) = 0x0100010001000100; ++ *((unsigned long *)&__m256i_op00) = 0x01ffff4300ffff00; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff00000000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x04e8296f08181818; ++ *((unsigned long *)&__m256i_op02) = 0x032feea900000000; ++ *((unsigned long *)&__m256i_op01) = 0x04e8296f08181818; ++ *((unsigned long *)&__m256i_op00) = 0x032feea900000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffff0000; ++ __m256i_out = __lasx_xvssrln_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrln_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op02) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffcfffcfffc; ++ *((unsigned long *)&__m256i_op00) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op02) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffc01fc01; ++ *((unsigned long *)&__m256i_op00) = 0x000000003fc03bbc; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x41cfe01dde000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x41cfe01dde000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000013fc03bbc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000013fc03bbc; ++ __m256i_out = __lasx_xvssrln_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fff8ff40; ++ *((unsigned long *)&__m256i_op02) = 0x0000ff0100090040; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fff8ff40; ++ *((unsigned long *)&__m256i_op00) = 0x0000ff0100090040; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op12) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000017f00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007f7f03030000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xdf80df80df80dfff; ++ *((unsigned long *)&__m256i_op02) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffdf80dfff; ++ *((unsigned long *)&__m256i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0101010101010101; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000017f7f7f7f; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000017f7f7f7f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000017fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000017fff; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffff800000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffff000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff000000017fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff000000017fff; ++ __m256i_out = __lasx_xvssrln_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrln_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000003fffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000003fffff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffff010100000001; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000000c; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrln_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlni.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlni.c +new file mode 100644 +index 000000000..116bebbb6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlni.c +@@ -0,0 +1,1130 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7f7f7f7f00007f7f; ++ *((unsigned long *)&__m256i_op00) = 0x3f28306860663e60; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ffff0000; ++ *((unsigned long *)&__m256i_op10) = 0x40d74f979f99419f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x7fff01fd7fff7fff; ++ *((unsigned long *)&__m256i_result0) = 0x00007fff7fff7fff; ++ __m256i_out = __lasx_xvssrlni_h_w (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffe0ffe0ffe0ffe0; ++ *((unsigned long *)&__m256i_op02) = 0xffe0ffe0ffe0ffe0; ++ *((unsigned long *)&__m256i_op01) = 0xffe0ffe0ffe0ffe0; ++ *((unsigned long *)&__m256i_op00) = 0xffe0ffe0ffe0ffe0; ++ *((unsigned long *)&__m256i_op13) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256i_op12) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x1e1800001e180000; ++ *((unsigned long *)&__m256i_op10) = 0x1e18000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000001e18; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ffe0; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000001e18; ++ __m256i_out = __lasx_xvssrlni_du_q (__m256i_op0, __m256i_op1, 0x70); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_wu_d (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op12) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op11) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_op10) = 0x1c1b1a191c1b1a19; ++ *((unsigned long *)&__m256i_result3) = 0x1fffffff1fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0383634303836343; ++ *((unsigned long *)&__m256i_result1) = 0x1fffffff1fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0383634303836343; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000401000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_du_q (__m256i_op0, __m256i_op1, 0x68); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x6c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0036003200360032; ++ *((unsigned long *)&__m256i_op02) = 0x0036003200360032; ++ *((unsigned long *)&__m256i_op01) = 0x0036003200360032; ++ *((unsigned long *)&__m256i_op00) = 0x0036003200360032; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_wu_d (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlni_wu_d (__m256i_op0, __m256i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000800000004; ++ *((unsigned long *)&__m256i_op02) = 0x0000bf6e0000c916; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000030000fff3; ++ *((unsigned long *)&__m256i_op13) = 0x001175f10e4330e8; ++ *((unsigned long *)&__m256i_op12) = 0xff8f0842ff29211e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfffff8d9ffa7103d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000e00ff00ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000ff00ff; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x18); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op11) = 0x7f80780000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffff00001000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff00001000; ++ __m256i_out = __lasx_xvssrlni_wu_d (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x39); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op12) = 0x6aeaeaeaeaeaeaea; ++ *((unsigned long *)&__m256i_op11) = 0xebebebebebebebeb; ++ *((unsigned long *)&__m256i_op10) = 0x6aeaeaeaeaeaeaea; ++ *((unsigned long *)&__m256i_result3) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000003f0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000003f0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000fffc0000fee0; ++ *((unsigned long *)&__m256i_op00) = 0x0000fe000000ffe0; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op12) = 0xfffffff900000003; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op10) = 0xfffffff900000003; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7ffe00007f000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x7ffe00007f000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffff0000ffff; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xe17cec8fe08008ac; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xe0801f41e0800168; ++ *((unsigned long *)&__m256i_op13) = 0x9240f24a84b18025; ++ *((unsigned long *)&__m256i_op12) = 0x9240f24a84b18025; ++ *((unsigned long *)&__m256i_op11) = 0xb2c0b341807f8006; ++ *((unsigned long *)&__m256i_op10) = 0xb2c0b341807f8006; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000012481e4950; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001658166830; ++ __m256i_out = __lasx_xvssrlni_du_q (__m256i_op0, __m256i_op1, 0x5b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x77777777f7777777; ++ *((unsigned long *)&__m256i_op02) = 0xf777777777777777; ++ *((unsigned long *)&__m256i_op01) = 0x77777777f7777777; ++ *((unsigned long *)&__m256i_op00) = 0xf777777777777777; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ff24; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ff24; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000003; ++ __m256i_out = __lasx_xvssrlni_wu_d (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op02) = 0x0000000040404240; ++ *((unsigned long *)&__m256i_op01) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040404240; ++ *((unsigned long *)&__m256i_op13) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000040404240; ++ *((unsigned long *)&__m256i_op11) = 0x0000000040404040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000040404240; ++ *((unsigned long *)&__m256i_result3) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_result2) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_result1) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_result0) = 0x00007f7f00007f7f; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_h_w (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op02) = 0x00010001000c4411; ++ *((unsigned long *)&__m256i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op00) = 0x0001000100044411; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000002800000010; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000002800000010; ++ *((unsigned long *)&__m256i_result3) = 0x0002000200020018; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0002000200020008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_h_w (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000c0000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x00000000c0000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000040000000; ++ *((unsigned long *)&__m256i_result3) = 0x0003030300000300; ++ *((unsigned long *)&__m256i_result2) = 0x0003030300000300; ++ *((unsigned long *)&__m256i_result1) = 0x0003030300000100; ++ *((unsigned long *)&__m256i_result0) = 0x0003030300000100; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000800000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000002000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000800000; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op02) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_result2) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_result1) = 0x00003fff00003fff; ++ *((unsigned long *)&__m256i_result0) = 0x00003fff00003fff; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op01) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007f000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007f00ff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0007fff8000ffff0; ++ *((unsigned long *)&__m256i_result3) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000030007; ++ *((unsigned long *)&__m256i_result1) = 0x00000000003f0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000030007; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000007f7f817f; ++ *((unsigned long *)&__m256i_op02) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op01) = 0x000000007f7f817f; ++ *((unsigned long *)&__m256i_op00) = 0x7f807f007f7f817f; ++ *((unsigned long *)&__m256i_op13) = 0x4ffc3f783fc040c0; ++ *((unsigned long *)&__m256i_op12) = 0x3fc03f803fc040c0; ++ *((unsigned long *)&__m256i_op11) = 0x4ffc3f783fc040c0; ++ *((unsigned long *)&__m256i_op10) = 0x3fc03f803fc040c0; ++ *((unsigned long *)&__m256i_result3) = 0x0003fbfc0bfbfc03; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0003fbfc0bfbfc03; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlni_du_q (__m256i_op0, __m256i_op1, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xff56ff55ff01ff01; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xff56ff55ff01ff01; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007f7f7f7f; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xa90896a400000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xa90896a400000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op12) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_op11) = 0x0000504fffff3271; ++ *((unsigned long *)&__m256i_op10) = 0xffff47b4ffff5879; ++ *((unsigned long *)&__m256i_result3) = 0x7f7f000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x007f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x7f7f000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x007f7f7f7f7f7f7f; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff80017fff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff80017fff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fffffff; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op02) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op01) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op00) = 0xf7f7f7f7f7f7f7f7; ++ *((unsigned long *)&__m256i_op13) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xfffffffe00000000; ++ __m256i_out = __lasx_xvssrlni_du_q (__m256i_op0, __m256i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x80000000ff810011; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x80000000ff810011; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0xffff8180ffff8181; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0xffff8180ffff8181; ++ *((unsigned long *)&__m256i_result3) = 0x000000008000ff00; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff81ff81; ++ *((unsigned long *)&__m256i_result1) = 0x000000008000ff00; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff81ff81; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffffebeeaaefafb; ++ *((unsigned long *)&__m256i_op12) = 0xfffffebeeaaeeeeb; ++ *((unsigned long *)&__m256i_op11) = 0xfffffebeeaaefafb; ++ *((unsigned long *)&__m256i_op10) = 0xfffffebeeaaeeeeb; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fefffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x01ffbfff00000000; ++ *((unsigned long *)&__m256i_result2) = 0x03ffffff03ffffff; ++ *((unsigned long *)&__m256i_result1) = 0x01ffbfff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x03ffffff03ffffff; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x26); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x001f001f001f001f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x001f001f001f001f; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x61); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0200000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0200000000000000; ++ __m256i_out = __lasx_xvssrlni_du_q (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x1f001f00000007ef; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x00001fff200007ef; ++ *((unsigned long *)&__m256i_result3) = 0x0000001f0000001f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000003030000; ++ *((unsigned long *)&__m256i_result1) = 0x0000001f0000001f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000030400; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x007000008e700000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x007000008e700000; ++ *((unsigned long *)&__m256i_op13) = 0x7171717171010101; ++ *((unsigned long *)&__m256i_op12) = 0x8e8e8e8e8f00ffff; ++ *((unsigned long *)&__m256i_op11) = 0x7171717171010101; ++ *((unsigned long *)&__m256i_op10) = 0x8e8e8e8e8f00ffff; ++ *((unsigned long *)&__m256i_result3) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result2) = 0xe2e2e202ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x000000000000ff00; ++ *((unsigned long *)&__m256i_result0) = 0xe2e2e202ffffffff; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_op02) = 0x8800c800c800c801; ++ *((unsigned long *)&__m256i_op01) = 0xc800c800c800c800; ++ *((unsigned long *)&__m256i_op00) = 0x8800c800c800c801; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op02) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_op01) = 0x0003800400038004; ++ *((unsigned long *)&__m256i_op00) = 0x000a800b000a800b; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000e0010000e; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000e0010000e; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x4e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_wu_d (__m256i_op0, __m256i_op1, 0x38); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xe07de0801f20607a; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x01ff01ff01c0003e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x01ff01ff01c0003e; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0707070707070707; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0707070707070707; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0018001800180018; ++ *((unsigned long *)&__m256i_op12) = 0x0018001800180018; ++ *((unsigned long *)&__m256i_op11) = 0x0018001800180018; ++ *((unsigned long *)&__m256i_op10) = 0x0018001800180018; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x3000300030003000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x3000300030003000; ++ __m256i_out = __lasx_xvssrlni_h_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op02) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op01) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op00) = 0x01fe01fe01fe01fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_wu_d (__m256i_op0, __m256i_op1, 0x35); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000598; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000598; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000002cc0000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000002cc0000; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x31); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_op02) = 0xff81001dff9d003b; ++ *((unsigned long *)&__m256i_op01) = 0xff81001dff9dff9e; ++ *((unsigned long *)&__m256i_op00) = 0xff81001dff9d003b; ++ *((unsigned long *)&__m256i_op13) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_op12) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_op11) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_op10) = 0x0002000200010002; ++ *((unsigned long *)&__m256i_result3) = 0x7f1d7f7f7f1d7f3b; ++ *((unsigned long *)&__m256i_result2) = 0x0202010202020102; ++ *((unsigned long *)&__m256i_result1) = 0x7f1d7f7f7f1d7f3b; ++ *((unsigned long *)&__m256i_result0) = 0x0202010202020102; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000dfffffff1; ++ *((unsigned long *)&__m256i_op02) = 0x0000000cfffffff3; ++ *((unsigned long *)&__m256i_op01) = 0x0000000dfffffff1; ++ *((unsigned long *)&__m256i_op00) = 0x0000000cfffffff3; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00003f3f00003f3f; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_op02) = 0x00000080c000c080; ++ *((unsigned long *)&__m256i_op01) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_op00) = 0x00000080c000c080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result1) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000004000; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x31); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op12) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op10) = 0x000000000010006d; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000004000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000004000000080; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000118; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000118; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_w_d (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x007efffefffefffe; ++ *((unsigned long *)&__m256i_op02) = 0xff80fffffffffffe; ++ *((unsigned long *)&__m256i_op01) = 0x007efffefffefffe; ++ *((unsigned long *)&__m256i_op00) = 0xff80fffffffffffe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000101; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0x0000e3ab0001352b; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0x0000e3ab0001352b; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_result2) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000038ea4d4a; ++ *((unsigned long *)&__m256i_result0) = 0x7fff00007fff0000; ++ __m256i_out = __lasx_xvssrlni_h_w (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_bu_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op02) = 0x000000a400ff004f; ++ *((unsigned long *)&__m256i_op01) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op00) = 0x000000a400ff004f; ++ *((unsigned long *)&__m256i_op13) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op12) = 0x000000a400ff004f; ++ *((unsigned long *)&__m256i_op11) = 0x000000010000005e; ++ *((unsigned long *)&__m256i_op10) = 0x000000a400ff004f; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_b_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x001fffffffe00011; ++ *((unsigned long *)&__m256i_op02) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x001fffffffe00011; ++ *((unsigned long *)&__m256i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffffffffffff; ++ __m256i_out = __lasx_xvssrlni_d_q (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlni_hu_w (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrn.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrn.c +new file mode 100644 +index 000000000..977061097 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrn.c +@@ -0,0 +1,815 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x1515151515151515; ++ *((unsigned long *)&__m256i_op02) = 0x1515151515151515; ++ *((unsigned long *)&__m256i_op01) = 0x1515151515151515; ++ *((unsigned long *)&__m256i_op00) = 0x1515151515151515; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xf800f800f800c000; ++ *((unsigned long *)&__m256i_op02) = 0xf800f800f800a000; ++ *((unsigned long *)&__m256i_op01) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_op00) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_op13) = 0xf800f800f800c000; ++ *((unsigned long *)&__m256i_op12) = 0xf800f800f800a000; ++ *((unsigned long *)&__m256i_op11) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_op10) = 0xf800f800f800e000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffefefffffcfa; ++ *((unsigned long *)&__m256i_op11) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffefefffffefe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_op12) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_op11) = 0x5555555536aaaaac; ++ *((unsigned long *)&__m256i_op10) = 0x55555555aaaaaaac; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_op02) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_op01) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_op00) = 0xfffc0000fffc0000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0002000200020002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0002000200020002; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op02) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op01) = 0xfff9fff9fff9fff9; ++ *((unsigned long *)&__m256i_op00) = 0xfff90000fff9fff9; ++ *((unsigned long *)&__m256i_op13) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op12) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_op11) = 0x108659e46485f7e1; ++ *((unsigned long *)&__m256i_op10) = 0x4df5b1a3ed5e02c1; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffff0004ff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffff0004ff; ++ __m256i_out = __lasx_xvssrlrn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000005be55bd2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xbabababababababa; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffef; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0404ffff00000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0404040800000010; ++ __m256i_out = __lasx_xvssrlrn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x007f00f8ff7fff80; ++ *((unsigned long *)&__m256i_op12) = 0x00000000fff6a9d8; ++ *((unsigned long *)&__m256i_op11) = 0x007f00f8ff7fff80; ++ *((unsigned long *)&__m256i_op10) = 0x00000000fff6a9d8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000002a54290; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ffff; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op02) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op01) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op00) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op13) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_op12) = 0x0000001b00fd0000; ++ *((unsigned long *)&__m256i_op11) = 0x0000001b0000001b; ++ *((unsigned long *)&__m256i_op10) = 0x0000001b00fd0000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000019; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000019; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000070700000707; ++ *((unsigned long *)&__m256i_op12) = 0x000009091b1b1212; ++ *((unsigned long *)&__m256i_op11) = 0x0000070700000707; ++ *((unsigned long *)&__m256i_op10) = 0x000009091b1b1212; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000027d00f8; ++ *((unsigned long *)&__m256i_op12) = 0x040204660265fe22; ++ *((unsigned long *)&__m256i_op11) = 0x00000000027d00f8; ++ *((unsigned long *)&__m256i_op10) = 0x040204660265fe22; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xe273e273e273e273; ++ *((unsigned long *)&__m256i_op02) = 0xe273e273e273e273; ++ *((unsigned long *)&__m256i_op01) = 0xe273e273e273e273; ++ *((unsigned long *)&__m256i_op00) = 0xe273e273e273e273; ++ *((unsigned long *)&__m256i_op13) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op12) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_op11) = 0xd207e90001fb16ef; ++ *((unsigned long *)&__m256i_op10) = 0xc8eab25698f97e90; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0001c4e8ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0001c4e8ffffffff; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x00000000000000ff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffff0000ff; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffff0000ff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00007f0200007f02; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00007f0200007f02; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0097011900f4009f; ++ *((unsigned long *)&__m256i_op02) = 0x003200d4010f0144; ++ *((unsigned long *)&__m256i_op01) = 0x0097011900f301cd; ++ *((unsigned long *)&__m256i_op00) = 0x010b008800f80153; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ff810011; ++ *((unsigned long *)&__m256i_op13) = 0x3fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op12) = 0x3fff8000ffa08004; ++ *((unsigned long *)&__m256i_op11) = 0x3fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_op10) = 0x3fff8000ffa08004; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000000ff01; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000000000ff01; ++ __m256i_out = __lasx_xvssrlrn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op02) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x00000000fc38fc38; ++ *((unsigned long *)&__m256i_op00) = 0xfc00000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffbfffa0ffffff80; ++ *((unsigned long *)&__m256i_op11) = 0xff00ff0000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffbfffa0ffffff80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff02000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff02000000; ++ __m256i_out = __lasx_xvssrlrn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_op02) = 0xa1a1a1a15e5e5e5e; ++ *((unsigned long *)&__m256i_op01) = 0xa1a1a1a1a1a1a1a1; ++ *((unsigned long *)&__m256i_op00) = 0xa1a1a1a15e5e5e5e; ++ *((unsigned long *)&__m256i_op13) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_op01) = 0x00000000457db03e; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff457db03f; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000ffff00020001; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000ffff00020001; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x000000007f7f7f80; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffff00000080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000007f007f007f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000002; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00ff0000ffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00ff0000ffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op12) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000ff00000000; ++ *((unsigned long *)&__m256i_op10) = 0x00ffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_op02) = 0x00000080c000c080; ++ *((unsigned long *)&__m256i_op01) = 0x4000c08000000080; ++ *((unsigned long *)&__m256i_op00) = 0x00000080c000c080; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op02) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000100010; ++ *((unsigned long *)&__m256i_op00) = 0x0010001000100010; ++ *((unsigned long *)&__m256i_op13) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000101000001010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000101000001010; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000404; ++ *((unsigned long *)&__m256i_op11) = 0x0000000001010101; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000404; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op12) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_op11) = 0x00000000ff88ffc0; ++ *((unsigned long *)&__m256i_op10) = 0x00000000ff78ffc0; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000002000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000002000000000; ++ __m256i_out = __lasx_xvssrlrn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op02) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0001000100010001; ++ *((unsigned long *)&__m256i_op12) = 0x0001000100800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000200a000020020; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000200a000020020; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_bu_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xff1cff1cff1c3fc7; ++ *((unsigned long *)&__m256i_op02) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op01) = 0xff1cff1cff1c3fc7; ++ *((unsigned long *)&__m256i_op00) = 0xff1cff1cff1cff1c; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000200000002; ++ __m256i_out = __lasx_xvssrlrn_w_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000100000100; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000100000100; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0002000200000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0002000200000000; ++ __m256i_out = __lasx_xvssrlrn_h_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000017f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000017f7f7f7f; ++ __m256i_out = __lasx_xvssrlrn_b_h (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op01) = 0x00000005ffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x00000007ffffffce; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op02) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op01) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op00) = 0x0000020000000200; ++ *((unsigned long *)&__m256i_op13) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op12) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op11) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op10) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrn_wu_d (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xf5fffc00fc000000; ++ *((unsigned long *)&__m256i_op13) = 0x0001001900010019; ++ *((unsigned long *)&__m256i_op12) = 0x0a02041904010019; ++ *((unsigned long *)&__m256i_op11) = 0x0001001900010019; ++ *((unsigned long *)&__m256i_op10) = 0x0a02041904010019; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000007b007e; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000007b007e; ++ __m256i_out = __lasx_xvssrlrn_hu_w (__m256i_op0, __m256i_op1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrni.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrni.c +new file mode 100644 +index 000000000..b55e388b1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvssrlrni.c +@@ -0,0 +1,1160 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlasx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lasxintrin.h> ++ ++int ++main () ++{ ++ __m256i __m256i_op0, __m256i_op1, __m256i_op2, __m256i_out, __m256i_result; ++ __m256 __m256_op0, __m256_op1, __m256_op2, __m256_out, __m256_result; ++ __m256d __m256d_op0, __m256d_op1, __m256d_op2, __m256d_out, __m256d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m256i_op03) = 0x3133c6409eecf8b0; ++ *((unsigned long *)&__m256i_op02) = 0xddf50db3c617a115; ++ *((unsigned long *)&__m256i_op01) = 0xa432ea5a0913dc8e; ++ *((unsigned long *)&__m256i_op00) = 0x29d403af367b4545; ++ *((unsigned long *)&__m256i_op13) = 0x38a966b31be83ee9; ++ *((unsigned long *)&__m256i_op12) = 0x5f6108dc25b8e028; ++ *((unsigned long *)&__m256i_op11) = 0xf41a56e8a20878d7; ++ *((unsigned long *)&__m256i_op10) = 0x683b8b67e20c8ee5; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7ffffffffffff7ff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffe06df0d7; ++ *((unsigned long *)&__m256i_op01) = 0x988eb37e000fb33d; ++ *((unsigned long *)&__m256i_op00) = 0xffffed95be394b1e; ++ *((unsigned long *)&__m256i_op13) = 0x8000ffff8000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x06f880008000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m256i_op10) = 0x800080008000b8f1; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ff00ff00; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ff00ff00; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000040100000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000040100000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000040100000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000040100000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0080200000802000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0080200000802000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000f18080010000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000f18080010000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_w_d (__m256i_op0, __m256i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_w_d (__m256i_op0, __m256i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000808080; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000808; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffefffffefc; ++ *((unsigned long *)&__m256i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000010; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x7c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000020afefb1; ++ *((unsigned long *)&__m256i_op12) = 0x7f350104f7ebffff; ++ *((unsigned long *)&__m256i_op11) = 0x00000000003fffc1; ++ *((unsigned long *)&__m256i_op10) = 0x005c0003fff9ffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000000fe6a021; ++ *((unsigned long *)&__m256i_result1) = 0x2000000020000000; ++ *((unsigned long *)&__m256i_result0) = 0x00000000000b8000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op12) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000020001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff7fff7fff; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result2) = 0x0020000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m256i_result0) = 0x0020000000000000; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x4b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op02) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op00) = 0x0400040004000400; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x33); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000100000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000002020000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000201eff0; ++ *((unsigned long *)&__m256i_op01) = 0x0000000002020000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000001fef010; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0010000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0010001000000000; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfffefffe00000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xfffefffefffefffd; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x7fff000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m256i_result0) = 0x7fff7fff00000000; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0x29); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0e0f1192846ff912; ++ *((unsigned long *)&__m256i_op02) = 0x002a0074666a4db9; ++ *((unsigned long *)&__m256i_op01) = 0x0e0f1192846ff912; ++ *((unsigned long *)&__m256i_op00) = 0x002a0074666a4db9; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000100000018; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000100000018; ++ *((unsigned long *)&__m256i_result3) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x7fff7fff05407fff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op02) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op01) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op00) = 0x0000001900000019; ++ *((unsigned long *)&__m256i_op13) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000007fff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0408040800000004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0408040800000004; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op12) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op11) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_op10) = 0x07efefefefefefee; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000001fbfbfc; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000001fbfbfc; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0x62); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0x0000fe01020b0001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0x0000fe01020b0001; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op02) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op02) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op00) = 0x2020202020202020; ++ *((unsigned long *)&__m256i_op13) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op12) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000202020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000404040; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000202020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000404040; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0x68); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x003f003f003f003f; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000010486048c; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000010486048c; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x6f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xfe7fffecfe7fffec; ++ *((unsigned long *)&__m256i_op12) = 0xff800000ff800000; ++ *((unsigned long *)&__m256i_op11) = 0xfe7fffecfe7fffec; ++ *((unsigned long *)&__m256i_op10) = 0xff80000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0808080808000800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0808080808000000; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff000c0000; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00040000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xd010101010101010; ++ *((unsigned long *)&__m256i_op02) = 0xd010101010103218; ++ *((unsigned long *)&__m256i_op01) = 0xd010101010101010; ++ *((unsigned long *)&__m256i_op00) = 0xd010101010103218; ++ *((unsigned long *)&__m256i_op13) = 0xd010101010101010; ++ *((unsigned long *)&__m256i_op12) = 0xd010101010103218; ++ *((unsigned long *)&__m256i_op11) = 0xd010101010101010; ++ *((unsigned long *)&__m256i_op10) = 0xd010101010103218; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m256i_result0) = 0x7fffffff7fffffff; ++ __m256i_out = __lasx_xvssrlrni_w_d (__m256i_op0, __m256i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000001ff8000; ++ *((unsigned long *)&__m256i_op02) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000001ff8000; ++ *((unsigned long *)&__m256i_op00) = 0xfffffe0000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_w_d (__m256i_op0, __m256i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0020000000200000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xbc30c40108a45423; ++ *((unsigned long *)&__m256i_op12) = 0xbc263e0e5d00e69f; ++ *((unsigned long *)&__m256i_op11) = 0xbc30c40108a4544b; ++ *((unsigned long *)&__m256i_op10) = 0xbc20e63aa8b9663f; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrni_hu_w (__m256i_op0, __m256i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0504080804030405; ++ *((unsigned long *)&__m256i_op02) = 0x0504060904040305; ++ *((unsigned long *)&__m256i_op01) = 0x0504080804030405; ++ *((unsigned long *)&__m256i_op00) = 0x0504060904040305; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000141020; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000141020; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x66); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xfffffffe00000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000080000000800; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000080000000800; ++ __m256i_out = __lasx_xvssrlrni_w_d (__m256i_op0, __m256i_op1, 0x35); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000010101010; ++ *((unsigned long *)&__m256i_result2) = 0x1010101010101010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000010101010; ++ *((unsigned long *)&__m256i_result0) = 0x1010101010101010; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000000000fe; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op02) = 0x0020000000200000; ++ *((unsigned long *)&__m256i_op01) = 0x0020002000200020; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op12) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m256i_result3) = 0x1010101010001000; ++ *((unsigned long *)&__m256i_result2) = 0x000000ff000000ff; ++ *((unsigned long *)&__m256i_result1) = 0x1010101000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000ff000000ff; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fff800000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x7fff800000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000465; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000008d00000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000008d00000000; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_du_q (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op02) = 0x000000007fe70000; ++ *((unsigned long *)&__m256i_op01) = 0x0000ffff8000ffa3; ++ *((unsigned long *)&__m256i_op00) = 0x000000007fe70000; ++ *((unsigned long *)&__m256i_op13) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op12) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_op11) = 0xc03ae000ffff6000; ++ *((unsigned long *)&__m256i_op10) = 0xc600000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000003; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000003; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x7e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0xfff10000fff10000; ++ *((unsigned long *)&__m256i_op13) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op12) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m256i_result3) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256i_result2) = 0x001fe020001fe020; ++ *((unsigned long *)&__m256i_result1) = 0x000000001ffe2000; ++ *((unsigned long *)&__m256i_result0) = 0x001fe020001fe020; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_hu_w (__m256i_op0, __m256i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000002000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000002000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_w_d (__m256i_op0, __m256i_op1, 0x38); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000004; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x7e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op02) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op01) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op00) = 0x0000000e0000000e; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_result2) = 0x00000000ffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0007000700070007; ++ *((unsigned long *)&__m256i_result0) = 0x00000000ffffffff; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_hu_w (__m256i_op0, __m256i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op02) = 0x007f010100000101; ++ *((unsigned long *)&__m256i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m256i_op00) = 0x007f010100000101; ++ *((unsigned long *)&__m256i_op13) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_op11) = 0x0000200000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000004000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0008000000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0008000000000010; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0xfefefefe3f800000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x000000007fff7fff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x000000007fff7fff; ++ __m256i_out = __lasx_xvssrlrni_h_w (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000080040; ++ *((unsigned long *)&__m256i_result3) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x000000000008002d; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x000000000008002d; ++ *((unsigned long *)&__m256i_op13) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x00000000007f0000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000010000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000010000000000; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x7fffffffffffbfff; ++ *((unsigned long *)&__m256i_op02) = 0x3f7f7f7f407fffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0x3f7f7f7f407fffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffff8000; ++ *((unsigned long *)&__m256i_op12) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x7efefefe80ffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result2) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000fdfdfe; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x07ffffff07ffffff; ++ *((unsigned long *)&__m256i_op02) = 0x07ffffff08000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x07ffffff08000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x207f207f207f2000; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x00000000207f2000; ++ *((unsigned long *)&__m256i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xfffeb68380002001; ++ *((unsigned long *)&__m256i_op02) = 0xfffe97c08000ffff; ++ *((unsigned long *)&__m256i_op01) = 0xfffeb68380002001; ++ *((unsigned long *)&__m256i_op00) = 0xfffe97c08000ffff; ++ *((unsigned long *)&__m256i_op13) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op12) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_op11) = 0xfffeb6839ffffd80; ++ *((unsigned long *)&__m256i_op10) = 0xfffe97c020010001; ++ *((unsigned long *)&__m256i_result3) = 0x0000007fff5b41c0; ++ *((unsigned long *)&__m256i_result2) = 0x0000007fff5b41d0; ++ *((unsigned long *)&__m256i_result1) = 0x0000007fff5b41c0; ++ *((unsigned long *)&__m256i_result0) = 0x0000007fff5b41d0; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x59); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000001000000010; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000001000000010; ++ __m256i_out = __lasx_xvssrlrni_w_d (__m256i_op0, __m256i_op1, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x00000000ffff97a2; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000001010000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_d_q (__m256i_op0, __m256i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x00ff00ff00c00040; ++ *((unsigned long *)&__m256i_op02) = 0x0000008000000001; ++ *((unsigned long *)&__m256i_op01) = 0x00ff00ff00c00040; ++ *((unsigned long *)&__m256i_op00) = 0x0000008000000001; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_bu_h (__m256i_op0, __m256i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0002000200000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0002000200000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x0000000020002000; ++ *((unsigned long *)&__m256i_result2) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result1) = 0x0000000020002000; ++ *((unsigned long *)&__m256i_result0) = 0xffffffffffffffff; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffff010100000001; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000008000000080; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000008000000080; ++ __m256i_out = __lasx_xvssrlrni_wu_d (__m256i_op0, __m256i_op1, 0x39); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op02) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op13) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op12) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result3) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result2) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m256i_result0) = 0x0000000000000000; ++ __m256i_out = __lasx_xvssrlrni_hu_w (__m256i_op0, __m256i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ *((unsigned long *)&__m256i_op03) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op02) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op13) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op12) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m256i_result3) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result2) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result1) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m256i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m256i_out = __lasx_xvssrlrni_b_h (__m256i_op0, __m256i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m256i_result, __m256i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-ASX-xvldrepl-xvstelm-instruc.patch
Added
@@ -0,0 +1,65 @@ +From 2ef90d604d7bae207d5b2067b4ce38d04d4835be Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 16:00:48 +0800 +Subject: PATCH 110/124 LoongArch: Add tests for ASX xvldrepl/xvstelm + instruction generation. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lasx/lasx-xvldrepl.c: New test. + * gcc.target/loongarch/vector/lasx/lasx-xvstelm.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lasx/lasx-xvldrepl.c | 16 ++++++++++++++++ + .../loongarch/vector/lasx/lasx-xvstelm.c | 14 ++++++++++++++ + 2 files changed, 30 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldrepl.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvstelm.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldrepl.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldrepl.c +new file mode 100644 +index 000000000..105567951 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvldrepl.c +@@ -0,0 +1,16 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O3 -mlasx" } */ ++/* { dg-final { scan-assembler-times "xvldrepl.w" 2} } */ ++ ++#define N 258 ++ ++float aN, bN, cN; ++ ++void ++test () ++{ ++ for (int i = 0; i < 256; i++) ++ { ++ ai = c0 * bi + c1; ++ } ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvstelm.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvstelm.c +new file mode 100644 +index 000000000..1a7b0e86f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-xvstelm.c +@@ -0,0 +1,14 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O3 -mlasx" } */ ++/* { dg-final { scan-assembler-times "xvstelm.w" 8} } */ ++ ++#define LEN 256 ++ ++float aLEN, bLEN, cLEN; ++ ++void ++test () ++{ ++ for (int i = 0; i < LEN; i += 2) ++ ai = bi + ci; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-Loongson-SX-builtin-function.patch
Added
@@ -0,0 +1,4354 @@ +From 1e9d9ec99e65201d8d926fddc89b6176abe9a4e6 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 09:38:42 +0800 +Subject: PATCH 078/124 LoongArch: Add tests for Loongson SX builtin + functions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-builtin.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-builtin.c | 4328 +++++++++++++++++ + 1 file changed, 4328 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-builtin.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-builtin.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-builtin.c +new file mode 100644 +index 000000000..13013114d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-builtin.c +@@ -0,0 +1,4328 @@ ++/* Test builtins for LOONGARCH LSX ASE instructions */ ++/* { dg-do compile } */ ++/* { dg-options "-mlsx" } */ ++/* { dg-final { scan-assembler-times "lsx_vsll_b:.*vsll\\.b.*lsx_vsll_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsll_h:.*vsll\\.h.*lsx_vsll_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsll_w:.*vsll\\.w.*lsx_vsll_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsll_d:.*vsll\\.d.*lsx_vsll_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslli_b:.*vslli\\.b.*lsx_vslli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslli_h:.*vslli\\.h.*lsx_vslli_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslli_w:.*vslli\\.w.*lsx_vslli_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslli_d:.*vslli\\.d.*lsx_vslli_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsra_b:.*vsra\\.b.*lsx_vsra_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsra_h:.*vsra\\.h.*lsx_vsra_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsra_w:.*vsra\\.w.*lsx_vsra_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsra_d:.*vsra\\.d.*lsx_vsra_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrai_b:.*vsrai\\.b.*lsx_vsrai_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrai_h:.*vsrai\\.h.*lsx_vsrai_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrai_w:.*vsrai\\.w.*lsx_vsrai_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrai_d:.*vsrai\\.d.*lsx_vsrai_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrar_b:.*vsrar\\.b.*lsx_vsrar_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrar_h:.*vsrar\\.h.*lsx_vsrar_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrar_w:.*vsrar\\.w.*lsx_vsrar_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrar_d:.*vsrar\\.d.*lsx_vsrar_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrari_b:.*vsrari\\.b.*lsx_vsrari_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrari_h:.*vsrari\\.h.*lsx_vsrari_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrari_w:.*vsrari\\.w.*lsx_vsrari_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrari_d:.*vsrari\\.d.*lsx_vsrari_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrl_b:.*vsrl\\.b.*lsx_vsrl_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrl_h:.*vsrl\\.h.*lsx_vsrl_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrl_w:.*vsrl\\.w.*lsx_vsrl_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrl_d:.*vsrl\\.d.*lsx_vsrl_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrli_b:.*vsrli\\.b.*lsx_vsrli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrli_h:.*vsrli\\.h.*lsx_vsrli_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrli_w:.*vsrli\\.w.*lsx_vsrli_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrli_d:.*vsrli\\.d.*lsx_vsrli_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlr_b:.*vsrlr\\.b.*lsx_vsrlr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlr_h:.*vsrlr\\.h.*lsx_vsrlr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlr_w:.*vsrlr\\.w.*lsx_vsrlr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlr_d:.*vsrlr\\.d.*lsx_vsrlr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlri_b:.*vsrlri\\.b.*lsx_vsrlri_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlri_h:.*vsrlri\\.h.*lsx_vsrlri_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlri_w:.*vsrlri\\.w.*lsx_vsrlri_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlri_d:.*vsrlri\\.d.*lsx_vsrlri_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclr_b:.*vbitclr\\.b.*lsx_vbitclr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclr_h:.*vbitclr\\.h.*lsx_vbitclr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclr_w:.*vbitclr\\.w.*lsx_vbitclr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclr_d:.*vbitclr\\.d.*lsx_vbitclr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclri_b:.*vbitclri\\.b.*lsx_vbitclri_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclri_h:.*vbitclri\\.h.*lsx_vbitclri_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclri_w:.*vbitclri\\.w.*lsx_vbitclri_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitclri_d:.*vbitclri\\.d.*lsx_vbitclri_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitset_b:.*vbitset\\.b.*lsx_vbitset_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitset_h:.*vbitset\\.h.*lsx_vbitset_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitset_w:.*vbitset\\.w.*lsx_vbitset_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitset_d:.*vbitset\\.d.*lsx_vbitset_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitseti_b:.*vbitseti\\.b.*lsx_vbitseti_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitseti_h:.*vbitseti\\.h.*lsx_vbitseti_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitseti_w:.*vbitseti\\.w.*lsx_vbitseti_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitseti_d:.*vbitseti\\.d.*lsx_vbitseti_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrev_b:.*vbitrev\\.b.*lsx_vbitrev_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrev_h:.*vbitrev\\.h.*lsx_vbitrev_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrev_w:.*vbitrev\\.w.*lsx_vbitrev_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrev_d:.*vbitrev\\.d.*lsx_vbitrev_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrevi_b:.*vbitrevi\\.b.*lsx_vbitrevi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrevi_h:.*vbitrevi\\.h.*lsx_vbitrevi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrevi_w:.*vbitrevi\\.w.*lsx_vbitrevi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitrevi_d:.*vbitrevi\\.d.*lsx_vbitrevi_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadd_b:.*vadd\\.b.*lsx_vadd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadd_h:.*vadd\\.h.*lsx_vadd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadd_w:.*vadd\\.w.*lsx_vadd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadd_d:.*vadd\\.d.*lsx_vadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddi_bu:.*vaddi\\.bu.*lsx_vaddi_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddi_hu:.*vaddi\\.hu.*lsx_vaddi_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddi_wu:.*vaddi\\.wu.*lsx_vaddi_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddi_du:.*vaddi\\.du.*lsx_vaddi_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsub_b:.*vsub\\.b.*lsx_vsub_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsub_h:.*vsub\\.h.*lsx_vsub_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsub_w:.*vsub\\.w.*lsx_vsub_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsub_d:.*vsub\\.d.*lsx_vsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubi_bu:.*vsubi\\.bu.*lsx_vsubi_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubi_hu:.*vsubi\\.hu.*lsx_vsubi_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubi_wu:.*vsubi\\.wu.*lsx_vsubi_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubi_du:.*vsubi\\.du.*lsx_vsubi_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_b:.*vmax\\.b.*lsx_vmax_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_h:.*vmax\\.h.*lsx_vmax_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_w:.*vmax\\.w.*lsx_vmax_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_d:.*vmax\\.d.*lsx_vmax_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_b:.*vmaxi\\.b.*lsx_vmaxi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_h:.*vmaxi\\.h.*lsx_vmaxi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_w:.*vmaxi\\.w.*lsx_vmaxi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_d:.*vmaxi\\.d.*lsx_vmaxi_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_bu:.*vmax\\.bu.*lsx_vmax_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_hu:.*vmax\\.hu.*lsx_vmax_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_wu:.*vmax\\.wu.*lsx_vmax_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmax_du:.*vmax\\.du.*lsx_vmax_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_bu:.*vmaxi\\.bu.*lsx_vmaxi_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_hu:.*vmaxi\\.hu.*lsx_vmaxi_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_wu:.*vmaxi\\.wu.*lsx_vmaxi_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaxi_du:.*vmaxi\\.du.*lsx_vmaxi_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_b:.*vmin\\.b.*lsx_vmin_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_h:.*vmin\\.h.*lsx_vmin_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_w:.*vmin\\.w.*lsx_vmin_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_d:.*vmin\\.d.*lsx_vmin_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_b:.*vmini\\.b.*lsx_vmini_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_h:.*vmini\\.h.*lsx_vmini_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_w:.*vmini\\.w.*lsx_vmini_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_d:.*vmini\\.d.*lsx_vmini_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_bu:.*vmin\\.bu.*lsx_vmin_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_hu:.*vmin\\.hu.*lsx_vmin_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_wu:.*vmin\\.wu.*lsx_vmin_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmin_du:.*vmin\\.du.*lsx_vmin_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_bu:.*vmini\\.bu.*lsx_vmini_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_hu:.*vmini\\.hu.*lsx_vmini_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_wu:.*vmini\\.wu.*lsx_vmini_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmini_du:.*vmini\\.du.*lsx_vmini_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseq_b:.*vseq\\.b.*lsx_vseq_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseq_h:.*vseq\\.h.*lsx_vseq_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseq_w:.*vseq\\.w.*lsx_vseq_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseq_d:.*vseq\\.d.*lsx_vseq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseqi_b:.*vseqi\\.b.*lsx_vseqi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseqi_h:.*vseqi\\.h.*lsx_vseqi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseqi_w:.*vseqi\\.w.*lsx_vseqi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vseqi_d:.*vseqi\\.d.*lsx_vseqi_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_b:.*vslti\\.b.*lsx_vslti_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_b:.*vslt\\.b.*lsx_vslt_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_h:.*vslt\\.h.*lsx_vslt_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_w:.*vslt\\.w.*lsx_vslt_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_d:.*vslt\\.d.*lsx_vslt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_h:.*vslti\\.h.*lsx_vslti_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_w:.*vslti\\.w.*lsx_vslti_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_d:.*vslti\\.d.*lsx_vslti_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_bu:.*vslt\\.bu.*lsx_vslt_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_hu:.*vslt\\.hu.*lsx_vslt_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_wu:.*vslt\\.wu.*lsx_vslt_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslt_du:.*vslt\\.du.*lsx_vslt_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_bu:.*vslti\\.bu.*lsx_vslti_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_hu:.*vslti\\.hu.*lsx_vslti_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_wu:.*vslti\\.wu.*lsx_vslti_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslti_du:.*vslti\\.du.*lsx_vslti_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_b:.*vsle\\.b.*lsx_vsle_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_h:.*vsle\\.h.*lsx_vsle_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_w:.*vsle\\.w.*lsx_vsle_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_d:.*vsle\\.d.*lsx_vsle_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_b:.*vslei\\.b.*lsx_vslei_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_h:.*vslei\\.h.*lsx_vslei_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_w:.*vslei\\.w.*lsx_vslei_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_d:.*vslei\\.d.*lsx_vslei_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_bu:.*vsle\\.bu.*lsx_vsle_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_hu:.*vsle\\.hu.*lsx_vsle_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_wu:.*vsle\\.wu.*lsx_vsle_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsle_du:.*vsle\\.du.*lsx_vsle_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_bu:.*vslei\\.bu.*lsx_vslei_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_hu:.*vslei\\.hu.*lsx_vslei_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_wu:.*vslei\\.wu.*lsx_vslei_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vslei_du:.*vslei\\.du.*lsx_vslei_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_b:.*vsat\\.b.*lsx_vsat_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_h:.*vsat\\.h.*lsx_vsat_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_w:.*vsat\\.w.*lsx_vsat_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_d:.*vsat\\.d.*lsx_vsat_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_bu:.*vsat\\.bu.*lsx_vsat_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_hu:.*vsat\\.hu.*lsx_vsat_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_wu:.*vsat\\.wu.*lsx_vsat_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsat_du:.*vsat\\.du.*lsx_vsat_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadda_b:.*vadda\\.b.*lsx_vadda_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadda_h:.*vadda\\.h.*lsx_vadda_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadda_w:.*vadda\\.w.*lsx_vadda_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadda_d:.*vadda\\.d.*lsx_vadda_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_b:.*vsadd\\.b.*lsx_vsadd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_h:.*vsadd\\.h.*lsx_vsadd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_w:.*vsadd\\.w.*lsx_vsadd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_d:.*vsadd\\.d.*lsx_vsadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_bu:.*vsadd\\.bu.*lsx_vsadd_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_hu:.*vsadd\\.hu.*lsx_vsadd_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_wu:.*vsadd\\.wu.*lsx_vsadd_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsadd_du:.*vsadd\\.du.*lsx_vsadd_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_b:.*vavg\\.b.*lsx_vavg_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_h:.*vavg\\.h.*lsx_vavg_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_w:.*vavg\\.w.*lsx_vavg_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_d:.*vavg\\.d.*lsx_vavg_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_bu:.*vavg\\.bu.*lsx_vavg_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_hu:.*vavg\\.hu.*lsx_vavg_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_wu:.*vavg\\.wu.*lsx_vavg_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavg_du:.*vavg\\.du.*lsx_vavg_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_b:.*vavgr\\.b.*lsx_vavgr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_h:.*vavgr\\.h.*lsx_vavgr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_w:.*vavgr\\.w.*lsx_vavgr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_d:.*vavgr\\.d.*lsx_vavgr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_bu:.*vavgr\\.bu.*lsx_vavgr_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_hu:.*vavgr\\.hu.*lsx_vavgr_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_wu:.*vavgr\\.wu.*lsx_vavgr_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vavgr_du:.*vavgr\\.du.*lsx_vavgr_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_b:.*vssub\\.b.*lsx_vssub_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_h:.*vssub\\.h.*lsx_vssub_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_w:.*vssub\\.w.*lsx_vssub_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_d:.*vssub\\.d.*lsx_vssub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_bu:.*vssub\\.bu.*lsx_vssub_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_hu:.*vssub\\.hu.*lsx_vssub_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_wu:.*vssub\\.wu.*lsx_vssub_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssub_du:.*vssub\\.du.*lsx_vssub_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_b:.*vabsd\\.b.*lsx_vabsd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_h:.*vabsd\\.h.*lsx_vabsd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_w:.*vabsd\\.w.*lsx_vabsd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_d:.*vabsd\\.d.*lsx_vabsd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_bu:.*vabsd\\.bu.*lsx_vabsd_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_hu:.*vabsd\\.hu.*lsx_vabsd_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_wu:.*vabsd\\.wu.*lsx_vabsd_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vabsd_du:.*vabsd\\.du.*lsx_vabsd_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmul_b:.*vmul\\.b.*lsx_vmul_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmul_h:.*vmul\\.h.*lsx_vmul_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmul_w:.*vmul\\.w.*lsx_vmul_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmul_d:.*vmul\\.d.*lsx_vmul_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmadd_b:.*vmadd\\.b.*lsx_vmadd_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmadd_h:.*vmadd\\.h.*lsx_vmadd_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmadd_w:.*vmadd\\.w.*lsx_vmadd_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmadd_d:.*vmadd\\.d.*lsx_vmadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmsub_b:.*vmsub\\.b.*lsx_vmsub_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmsub_h:.*vmsub\\.h.*lsx_vmsub_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmsub_w:.*vmsub\\.w.*lsx_vmsub_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmsub_d:.*vmsub\\.d.*lsx_vmsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_b:.*vdiv\\.b.*lsx_vdiv_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_h:.*vdiv\\.h.*lsx_vdiv_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_w:.*vdiv\\.w.*lsx_vdiv_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_d:.*vdiv\\.d.*lsx_vdiv_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_bu:.*vdiv\\.bu.*lsx_vdiv_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_hu:.*vdiv\\.hu.*lsx_vdiv_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_wu:.*vdiv\\.wu.*lsx_vdiv_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vdiv_du:.*vdiv\\.du.*lsx_vdiv_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_h_b:.*vhaddw\\.h\\.b.*lsx_vhaddw_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_w_h:.*vhaddw\\.w\\.h.*lsx_vhaddw_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_d_w:.*vhaddw\\.d\\.w.*lsx_vhaddw_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_hu_bu:.*vhaddw\\.hu\\.bu.*lsx_vhaddw_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_wu_hu:.*vhaddw\\.wu\\.hu.*lsx_vhaddw_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_du_wu:.*vhaddw\\.du\\.wu.*lsx_vhaddw_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_h_b:.*vhsubw\\.h\\.b.*lsx_vhsubw_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_w_h:.*vhsubw\\.w\\.h.*lsx_vhsubw_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_d_w:.*vhsubw\\.d\\.w.*lsx_vhsubw_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_hu_bu:.*vhsubw\\.hu\\.bu.*lsx_vhsubw_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_wu_hu:.*vhsubw\\.wu\\.hu.*lsx_vhsubw_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_du_wu:.*vhsubw\\.du\\.wu.*lsx_vhsubw_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_b:.*vmod\\.b.*lsx_vmod_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_h:.*vmod\\.h.*lsx_vmod_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_w:.*vmod\\.w.*lsx_vmod_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_d:.*vmod\\.d.*lsx_vmod_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_bu:.*vmod\\.bu.*lsx_vmod_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_hu:.*vmod\\.hu.*lsx_vmod_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_wu:.*vmod\\.wu.*lsx_vmod_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmod_du:.*vmod\\.du.*lsx_vmod_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplve_b:.*vreplve\\.b.*lsx_vreplve_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplve_h:.*vreplve\\.h.*lsx_vreplve_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplve_w:.*vreplve\\.w.*lsx_vreplve_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplve_d:.*vreplve\\.d.*lsx_vreplve_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplvei_b:.*vreplvei\\.b.*lsx_vreplvei_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplvei_h:.*vreplvei\\.h.*lsx_vreplvei_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplvei_w:.*vreplvei\\.w.*lsx_vreplvei_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplvei_d:.*vreplvei\\.d.*lsx_vreplvei_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickev_b:.*vpickev\\.b.*lsx_vpickev_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickev_h:.*vpickev\\.h.*lsx_vpickev_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickev_w:.*vpickev\\.w.*lsx_vpickev_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickev_d:.*vilvl\\.d.*lsx_vpickev_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickod_b:.*vpickod\\.b.*lsx_vpickod_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickod_h:.*vpickod\\.h.*lsx_vpickod_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickod_w:.*vpickod\\.w.*lsx_vpickod_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickod_d:.*vilvh\\.d.*lsx_vpickod_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvh_b:.*vilvh\\.b.*lsx_vilvh_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvh_h:.*vilvh\\.h.*lsx_vilvh_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvh_w:.*vilvh\\.w.*lsx_vilvh_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvh_d:.*vilvh\\.d.*lsx_vilvh_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvl_b:.*vilvl\\.b.*lsx_vilvl_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvl_h:.*vilvl\\.h.*lsx_vilvl_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvl_w:.*vilvl\\.w.*lsx_vilvl_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vilvl_d:.*vilvl\\.d.*lsx_vilvl_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackev_b:.*vpackev\\.b.*lsx_vpackev_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackev_h:.*vpackev\\.h.*lsx_vpackev_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackev_w:.*vpackev\\.w.*lsx_vpackev_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackev_d:.*vilvl\\.d.*lsx_vpackev_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackod_b:.*vpackod\\.b.*lsx_vpackod_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackod_h:.*vpackod\\.h.*lsx_vpackod_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackod_w:.*vpackod\\.w.*lsx_vpackod_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpackod_d:.*vilvh\\.d.*lsx_vpackod_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf_h:.*vshuf\\.h.*lsx_vshuf_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf_w:.*vshuf\\.w.*lsx_vshuf_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf_d:.*vshuf\\.d.*lsx_vshuf_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vand_v:.*vand\\.v.*lsx_vand_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vandi_b:.*vandi\\.b.*lsx_vandi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vor_v:.*vor\\.v.*lsx_vor_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vori_b:.*vbitseti\\.b.*lsx_vori_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vnor_v:.*vnor\\.v.*lsx_vnor_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vnori_b:.*vnori\\.b.*lsx_vnori_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vxor_v:.*vxor\\.v.*lsx_vxor_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vxori_b:.*vbitrevi\\.b.*lsx_vxori_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitsel_v:.*vbitsel\\.v.*lsx_vbitsel_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbitseli_b:.*vbitseli\\.b.*lsx_vbitseli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf4i_b:.*vshuf4i\\.b.*lsx_vshuf4i_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf4i_h:.*vshuf4i\\.h.*lsx_vshuf4i_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf4i_w:.*vshuf4i\\.w.*lsx_vshuf4i_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplgr2vr_b:.*vreplgr2vr\\.b.*lsx_vreplgr2vr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplgr2vr_h:.*vreplgr2vr\\.h.*lsx_vreplgr2vr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplgr2vr_w:.*vreplgr2vr\\.w.*lsx_vreplgr2vr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vreplgr2vr_d:.*vreplgr2vr\\.d.*lsx_vreplgr2vr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpcnt_b:.*vpcnt\\.b.*lsx_vpcnt_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpcnt_h:.*vpcnt\\.h.*lsx_vpcnt_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpcnt_w:.*vpcnt\\.w.*lsx_vpcnt_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpcnt_d:.*vpcnt\\.d.*lsx_vpcnt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclo_b:.*vclo\\.b.*lsx_vclo_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclo_h:.*vclo\\.h.*lsx_vclo_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclo_w:.*vclo\\.w.*lsx_vclo_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclo_d:.*vclo\\.d.*lsx_vclo_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclz_b:.*vclz\\.b.*lsx_vclz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclz_h:.*vclz\\.h.*lsx_vclz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclz_w:.*vclz\\.w.*lsx_vclz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vclz_d:.*vclz\\.d.*lsx_vclz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_b:.*vpickve2gr\\.b.*lsx_vpickve2gr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_h:.*vpickve2gr\\.h.*lsx_vpickve2gr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_w:.*vpickve2gr\\.w.*lsx_vpickve2gr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_d:.*vpickve2gr\\.d.*lsx_vpickve2gr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_bu:.*vpickve2gr\\.bu.*lsx_vpickve2gr_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_hu:.*vpickve2gr\\.hu.*lsx_vpickve2gr_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_wu:.*vpickve2gr\\.wu.*lsx_vpickve2gr_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpickve2gr_du:.*vpickve2gr\\.du.*lsx_vpickve2gr_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vinsgr2vr_b:.*vinsgr2vr\\.b.*lsx_vinsgr2vr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vinsgr2vr_h:.*vinsgr2vr\\.h.*lsx_vinsgr2vr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vinsgr2vr_w:.*vinsgr2vr\\.w.*lsx_vinsgr2vr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vinsgr2vr_d:.*vinsgr2vr\\.d.*lsx_vinsgr2vr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfadd_s:.*vfadd\\.s.*lsx_vfadd_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfadd_d:.*vfadd\\.d.*lsx_vfadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfsub_s:.*vfsub\\.s.*lsx_vfsub_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfsub_d:.*vfsub\\.d.*lsx_vfsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmul_s:.*vfmul\\.s.*lsx_vfmul_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmul_d:.*vfmul\\.d.*lsx_vfmul_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfdiv_s:.*vfdiv\\.s.*lsx_vfdiv_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfdiv_d:.*vfdiv\\.d.*lsx_vfdiv_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcvt_h_s:.*vfcvt\\.h\\.s.*lsx_vfcvt_h_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcvt_s_d:.*vfcvt\\.s\\.d.*lsx_vfcvt_s_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmin_s:.*vfmin\\.s.*lsx_vfmin_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmin_d:.*vfmin\\.d.*lsx_vfmin_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmina_s:.*vfmina\\.s.*lsx_vfmina_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmina_d:.*vfmina\\.d.*lsx_vfmina_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmax_s:.*vfmax\\.s.*lsx_vfmax_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmax_d:.*vfmax\\.d.*lsx_vfmax_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmaxa_s:.*vfmaxa\\.s.*lsx_vfmaxa_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmaxa_d:.*vfmaxa\\.d.*lsx_vfmaxa_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfclass_s:.*vfclass\\.s.*lsx_vfclass_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfclass_d:.*vfclass\\.d.*lsx_vfclass_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfsqrt_s:.*vfsqrt\\.s.*lsx_vfsqrt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfsqrt_d:.*vfsqrt\\.d.*lsx_vfsqrt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrecip_s:.*vfrecip\\.s.*lsx_vfrecip_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrecip_d:.*vfrecip\\.d.*lsx_vfrecip_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrint_s:.*vfrint\\.s.*lsx_vfrint_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrint_d:.*vfrint\\.d.*lsx_vfrint_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrsqrt_s:.*vfrsqrt\\.s.*lsx_vfrsqrt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrsqrt_d:.*vfrsqrt\\.d.*lsx_vfrsqrt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vflogb_s:.*vflogb\\.s.*lsx_vflogb_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vflogb_d:.*vflogb\\.d.*lsx_vflogb_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcvth_s_h:.*vfcvth\\.s\\.h.*lsx_vfcvth_s_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcvth_d_s:.*vfcvth\\.d\\.s.*lsx_vfcvth_d_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcvtl_s_h:.*vfcvtl\\.s\\.h.*lsx_vfcvtl_s_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcvtl_d_s:.*vfcvtl\\.d\\.s.*lsx_vfcvtl_d_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftint_w_s:.*vftint\\.w\\.s.*lsx_vftint_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftint_l_d:.*vftint\\.l\\.d.*lsx_vftint_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftint_wu_s:.*vftint\\.wu\\.s.*lsx_vftint_wu_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftint_lu_d:.*vftint\\.lu\\.d.*lsx_vftint_lu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrz_w_s:.*vftintrz\\.w\\.s.*lsx_vftintrz_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrz_l_d:.*vftintrz\\.l\\.d.*lsx_vftintrz_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrz_wu_s:.*vftintrz\\.wu\\.s.*lsx_vftintrz_wu_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrz_lu_d:.*vftintrz\\.lu\\.d.*lsx_vftintrz_lu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vffint_s_w:.*vffint\\.s\\.w.*lsx_vffint_s_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vffint_d_l:.*vffint\\.d\\.l.*lsx_vffint_d_l" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vffint_s_wu:.*vffint\\.s\\.wu.*lsx_vffint_s_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vffint_d_lu:.*vffint\\.d\\.lu.*lsx_vffint_d_lu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vandn_v:.*vandn\\.v.*lsx_vandn_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vneg_b:.*vneg\\.b.*lsx_vneg_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vneg_h:.*vneg\\.h.*lsx_vneg_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vneg_w:.*vneg\\.w.*lsx_vneg_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vneg_d:.*vneg\\.d.*lsx_vneg_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_b:.*vmuh\\.b.*lsx_vmuh_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_h:.*vmuh\\.h.*lsx_vmuh_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_w:.*vmuh\\.w.*lsx_vmuh_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_d:.*vmuh\\.d.*lsx_vmuh_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_bu:.*vmuh\\.bu.*lsx_vmuh_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_hu:.*vmuh\\.hu.*lsx_vmuh_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_wu:.*vmuh\\.wu.*lsx_vmuh_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmuh_du:.*vmuh\\.du.*lsx_vmuh_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsllwil_h_b:.*vsllwil\\.h\\.b.*lsx_vsllwil_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsllwil_w_h:.*vsllwil\\.w\\.h.*lsx_vsllwil_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsllwil_d_w:.*vsllwil\\.d\\.w.*lsx_vsllwil_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsllwil_hu_bu:.*vsllwil\\.hu\\.bu.*lsx_vsllwil_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsllwil_wu_hu:.*vsllwil\\.wu\\.hu.*lsx_vsllwil_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsllwil_du_wu:.*vsllwil\\.du\\.wu.*lsx_vsllwil_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsran_b_h:.*vsran\\.b\\.h.*lsx_vsran_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsran_h_w:.*vsran\\.h\\.w.*lsx_vsran_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsran_w_d:.*vsran\\.w\\.d.*lsx_vsran_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssran_b_h:.*vssran\\.b\\.h.*lsx_vssran_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssran_h_w:.*vssran\\.h\\.w.*lsx_vssran_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssran_w_d:.*vssran\\.w\\.d.*lsx_vssran_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssran_bu_h:.*vssran\\.bu\\.h.*lsx_vssran_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssran_hu_w:.*vssran\\.hu\\.w.*lsx_vssran_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssran_wu_d:.*vssran\\.wu\\.d.*lsx_vssran_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrarn_b_h:.*vsrarn\\.b\\.h.*lsx_vsrarn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrarn_h_w:.*vsrarn\\.h\\.w.*lsx_vsrarn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrarn_w_d:.*vsrarn\\.w\\.d.*lsx_vsrarn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarn_b_h:.*vssrarn\\.b\\.h.*lsx_vssrarn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarn_h_w:.*vssrarn\\.h\\.w.*lsx_vssrarn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarn_w_d:.*vssrarn\\.w\\.d.*lsx_vssrarn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarn_bu_h:.*vssrarn\\.bu\\.h.*lsx_vssrarn_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarn_hu_w:.*vssrarn\\.hu\\.w.*lsx_vssrarn_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarn_wu_d:.*vssrarn\\.wu\\.d.*lsx_vssrarn_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrln_b_h:.*vsrln\\.b\\.h.*lsx_vsrln_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrln_h_w:.*vsrln\\.h\\.w.*lsx_vsrln_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrln_w_d:.*vsrln\\.w\\.d.*lsx_vsrln_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrln_bu_h:.*vssrln\\.bu\\.h.*lsx_vssrln_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrln_hu_w:.*vssrln\\.hu\\.w.*lsx_vssrln_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrln_wu_d:.*vssrln\\.wu\\.d.*lsx_vssrln_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlrn_b_h:.*vsrlrn\\.b\\.h.*lsx_vsrlrn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlrn_h_w:.*vsrlrn\\.h\\.w.*lsx_vsrlrn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlrn_w_d:.*vsrlrn\\.w\\.d.*lsx_vsrlrn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrn_bu_h:.*vssrlrn\\.bu\\.h.*lsx_vssrlrn_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrn_hu_w:.*vssrlrn\\.hu\\.w.*lsx_vssrlrn_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrn_wu_d:.*vssrlrn\\.wu\\.d.*lsx_vssrlrn_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrstpi_b:.*vfrstpi\\.b.*lsx_vfrstpi_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrstpi_h:.*vfrstpi\\.h.*lsx_vfrstpi_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrstp_b:.*vfrstp\\.b.*lsx_vfrstp_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrstp_h:.*vfrstp\\.h.*lsx_vfrstp_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf4i_d:.*vshuf4i\\.d.*lsx_vshuf4i_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbsrl_v:.*vbsrl\\.v.*lsx_vbsrl_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vbsll_v:.*vbsll\\.v.*lsx_vbsll_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vextrins_b:.*vextrins\\.b.*lsx_vextrins_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vextrins_h:.*vextrins\\.h.*lsx_vextrins_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vextrins_w:.*vextrins\\.w.*lsx_vextrins_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vextrins_d:.*vextrins\\.d.*lsx_vextrins_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmskltz_b:.*vmskltz\\.b.*lsx_vmskltz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmskltz_h:.*vmskltz\\.h.*lsx_vmskltz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmskltz_w:.*vmskltz\\.w.*lsx_vmskltz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmskltz_d:.*vmskltz\\.d.*lsx_vmskltz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsigncov_b:.*vsigncov\\.b.*lsx_vsigncov_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsigncov_h:.*vsigncov\\.h.*lsx_vsigncov_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsigncov_w:.*vsigncov\\.w.*lsx_vsigncov_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsigncov_d:.*vsigncov\\.d.*lsx_vsigncov_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmadd_s:.*vfmadd\\.s.*lsx_vfmadd_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmadd_d:.*vfmadd\\.d.*lsx_vfmadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmsub_s:.*vfmsub\\.s.*lsx_vfmsub_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfmsub_d:.*vfmsub\\.d.*lsx_vfmsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfnmadd_s:.*vfnmadd\\.s.*lsx_vfnmadd_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfnmadd_d:.*vfnmadd\\.d.*lsx_vfnmadd_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfnmsub_s:.*vfnmsub\\.s.*lsx_vfnmsub_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfnmsub_d:.*vfnmsub\\.d.*lsx_vfnmsub_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrne_w_s:.*vftintrne\\.w\\.s.*lsx_vftintrne_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrne_l_d:.*vftintrne\\.l\\.d.*lsx_vftintrne_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrp_w_s:.*vftintrp\\.w\\.s.*lsx_vftintrp_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrp_l_d:.*vftintrp\\.l\\.d.*lsx_vftintrp_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrm_w_s:.*vftintrm\\.w\\.s.*lsx_vftintrm_w_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrm_l_d:.*vftintrm\\.l\\.d.*lsx_vftintrm_l_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftint_w_d:.*vftint\\.w\\.d.*lsx_vftint_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vffint_s_l:.*vffint\\.s\\.l.*lsx_vffint_s_l" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrz_w_d:.*vftintrz\\.w\\.d.*lsx_vftintrz_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrp_w_d:.*vftintrp\\.w\\.d.*lsx_vftintrp_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrm_w_d:.*vftintrm\\.w\\.d.*lsx_vftintrm_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrne_w_d:.*vftintrne\\.w\\.d.*lsx_vftintrne_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintl_l_s:.*vftintl\\.l\\.s.*lsx_vftintl_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftinth_l_s:.*vftinth\\.l\\.s.*lsx_vftinth_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vffinth_d_w:.*vffinth\\.d\\.w.*lsx_vffinth_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vffintl_d_w:.*vffintl\\.d\\.w.*lsx_vffintl_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrzl_l_s:.*vftintrzl\\.l\\.s.*lsx_vftintrzl_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrzh_l_s:.*vftintrzh\\.l\\.s.*lsx_vftintrzh_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrpl_l_s:.*vftintrpl\\.l\\.s.*lsx_vftintrpl_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrph_l_s:.*vftintrph\\.l\\.s.*lsx_vftintrph_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrml_l_s:.*vftintrml\\.l\\.s.*lsx_vftintrml_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrmh_l_s:.*vftintrmh\\.l\\.s.*lsx_vftintrmh_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrnel_l_s:.*vftintrnel\\.l\\.s.*lsx_vftintrnel_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vftintrneh_l_s:.*vftintrneh\\.l\\.s.*lsx_vftintrneh_l_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrne_s:.*vfrintrne\\.s.*lsx_vfrintrne_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrne_d:.*vfrintrne\\.d.*lsx_vfrintrne_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrz_s:.*vfrintrz\\.s.*lsx_vfrintrz_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrz_d:.*vfrintrz\\.d.*lsx_vfrintrz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrp_s:.*vfrintrp\\.s.*lsx_vfrintrp_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrp_d:.*vfrintrp\\.d.*lsx_vfrintrp_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrm_s:.*vfrintrm\\.s.*lsx_vfrintrm_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfrintrm_d:.*vfrintrm\\.d.*lsx_vfrintrm_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vstelm_b:.*vstelm\\.b.*lsx_vstelm_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vstelm_h:.*vstelm\\.h.*lsx_vstelm_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vstelm_w:.*vstelm\\.w.*lsx_vstelm_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vstelm_d:.*vstelm\\.d.*lsx_vstelm_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_d_w:.*vaddwev\\.d\\.w.*lsx_vaddwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_w_h:.*vaddwev\\.w\\.h.*lsx_vaddwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_h_b:.*vaddwev\\.h\\.b.*lsx_vaddwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_d_w:.*vaddwod\\.d\\.w.*lsx_vaddwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_w_h:.*vaddwod\\.w\\.h.*lsx_vaddwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_h_b:.*vaddwod\\.h\\.b.*lsx_vaddwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_d_wu:.*vaddwev\\.d\\.wu.*lsx_vaddwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_w_hu:.*vaddwev\\.w\\.hu.*lsx_vaddwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_h_bu:.*vaddwev\\.h\\.bu.*lsx_vaddwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_d_wu:.*vaddwod\\.d\\.wu.*lsx_vaddwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_w_hu:.*vaddwod\\.w\\.hu.*lsx_vaddwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_h_bu:.*vaddwod\\.h\\.bu.*lsx_vaddwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_d_wu_w:.*vaddwev\\.d\\.wu\\.w.*lsx_vaddwev_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_w_hu_h:.*vaddwev\\.w\\.hu\\.h.*lsx_vaddwev_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_h_bu_b:.*vaddwev\\.h\\.bu\\.b.*lsx_vaddwev_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_d_wu_w:.*vaddwod\\.d\\.wu\\.w.*lsx_vaddwod_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_w_hu_h:.*vaddwod\\.w\\.hu\\.h.*lsx_vaddwod_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_h_bu_b:.*vaddwod\\.h\\.bu\\.b.*lsx_vaddwod_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_d_w:.*vsubwev\\.d\\.w.*lsx_vsubwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_w_h:.*vsubwev\\.w\\.h.*lsx_vsubwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_h_b:.*vsubwev\\.h\\.b.*lsx_vsubwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_d_w:.*vsubwod\\.d\\.w.*lsx_vsubwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_w_h:.*vsubwod\\.w\\.h.*lsx_vsubwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_h_b:.*vsubwod\\.h\\.b.*lsx_vsubwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_d_wu:.*vsubwev\\.d\\.wu.*lsx_vsubwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_w_hu:.*vsubwev\\.w\\.hu.*lsx_vsubwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_h_bu:.*vsubwev\\.h\\.bu.*lsx_vsubwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_d_wu:.*vsubwod\\.d\\.wu.*lsx_vsubwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_w_hu:.*vsubwod\\.w\\.hu.*lsx_vsubwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_h_bu:.*vsubwod\\.h\\.bu.*lsx_vsubwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_q_d:.*vaddwev\\.q\\.d.*lsx_vaddwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_q_d:.*vaddwod\\.q\\.d.*lsx_vaddwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_q_du:.*vaddwev\\.q\\.du.*lsx_vaddwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_q_du:.*vaddwod\\.q\\.du.*lsx_vaddwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_q_d:.*vsubwev\\.q\\.d.*lsx_vsubwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_q_d:.*vsubwod\\.q\\.d.*lsx_vsubwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwev_q_du:.*vsubwev\\.q\\.du.*lsx_vsubwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsubwod_q_du:.*vsubwod\\.q\\.du.*lsx_vsubwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwev_q_du_d:.*vaddwev\\.q\\.du\\.d.*lsx_vaddwev_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vaddwod_q_du_d:.*vaddwod\\.q\\.du\\.d.*lsx_vaddwod_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_d_w:.*vmulwev\\.d\\.w.*lsx_vmulwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_w_h:.*vmulwev\\.w\\.h.*lsx_vmulwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_h_b:.*vmulwev\\.h\\.b.*lsx_vmulwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_d_w:.*vmulwod\\.d\\.w.*lsx_vmulwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_w_h:.*vmulwod\\.w\\.h.*lsx_vmulwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_h_b:.*vmulwod\\.h\\.b.*lsx_vmulwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_d_wu:.*vmulwev\\.d\\.wu.*lsx_vmulwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_w_hu:.*vmulwev\\.w\\.hu.*lsx_vmulwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_h_bu:.*vmulwev\\.h\\.bu.*lsx_vmulwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_d_wu:.*vmulwod\\.d\\.wu.*lsx_vmulwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_w_hu:.*vmulwod\\.w\\.hu.*lsx_vmulwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_h_bu:.*vmulwod\\.h\\.bu.*lsx_vmulwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_d_wu_w:.*vmulwev\\.d\\.wu\\.w.*lsx_vmulwev_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_w_hu_h:.*vmulwev\\.w\\.hu\\.h.*lsx_vmulwev_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_h_bu_b:.*vmulwev\\.h\\.bu\\.b.*lsx_vmulwev_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_d_wu_w:.*vmulwod\\.d\\.wu\\.w.*lsx_vmulwod_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_w_hu_h:.*vmulwod\\.w\\.hu\\.h.*lsx_vmulwod_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_h_bu_b:.*vmulwod\\.h\\.bu\\.b.*lsx_vmulwod_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_q_d:.*vmulwev\\.q\\.d.*lsx_vmulwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_q_d:.*vmulwod\\.q\\.d.*lsx_vmulwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_q_du:.*vmulwev\\.q\\.du.*lsx_vmulwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_q_du:.*vmulwod\\.q\\.du.*lsx_vmulwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwev_q_du_d:.*vmulwev\\.q\\.du\\.d.*lsx_vmulwev_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmulwod_q_du_d:.*vmulwod\\.q\\.du\\.d.*lsx_vmulwod_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_q_d:.*vhaddw\\.q\\.d.*lsx_vhaddw_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhaddw_qu_du:.*vhaddw\\.qu\\.du.*lsx_vhaddw_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_q_d:.*vhsubw\\.q\\.d.*lsx_vhsubw_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vhsubw_qu_du:.*vhsubw\\.qu\\.du.*lsx_vhsubw_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_d_w:.*vmaddwev\\.d\\.w.*lsx_vmaddwev_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_w_h:.*vmaddwev\\.w\\.h.*lsx_vmaddwev_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_h_b:.*vmaddwev\\.h\\.b.*lsx_vmaddwev_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_d_wu:.*vmaddwev\\.d\\.wu.*lsx_vmaddwev_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_w_hu:.*vmaddwev\\.w\\.hu.*lsx_vmaddwev_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_h_bu:.*vmaddwev\\.h\\.bu.*lsx_vmaddwev_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_d_w:.*vmaddwod\\.d\\.w.*lsx_vmaddwod_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_w_h:.*vmaddwod\\.w\\.h.*lsx_vmaddwod_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_h_b:.*vmaddwod\\.h\\.b.*lsx_vmaddwod_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_d_wu:.*vmaddwod\\.d\\.wu.*lsx_vmaddwod_d_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_w_hu:.*vmaddwod\\.w\\.hu.*lsx_vmaddwod_w_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_h_bu:.*vmaddwod\\.h\\.bu.*lsx_vmaddwod_h_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_d_wu_w:.*vmaddwev\\.d\\.wu\\.w.*lsx_vmaddwev_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_w_hu_h:.*vmaddwev\\.w\\.hu\\.h.*lsx_vmaddwev_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_h_bu_b:.*vmaddwev\\.h\\.bu\\.b.*lsx_vmaddwev_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_d_wu_w:.*vmaddwod\\.d\\.wu\\.w.*lsx_vmaddwod_d_wu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_w_hu_h:.*vmaddwod\\.w\\.hu\\.h.*lsx_vmaddwod_w_hu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_h_bu_b:.*vmaddwod\\.h\\.bu\\.b.*lsx_vmaddwod_h_bu_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_q_d:.*vmaddwev\\.q\\.d.*lsx_vmaddwev_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_q_d:.*vmaddwod\\.q\\.d.*lsx_vmaddwod_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_q_du:.*vmaddwev\\.q\\.du.*lsx_vmaddwev_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_q_du:.*vmaddwod\\.q\\.du.*lsx_vmaddwod_q_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwev_q_du_d:.*vmaddwev\\.q\\.du\\.d.*lsx_vmaddwev_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmaddwod_q_du_d:.*vmaddwod\\.q\\.du\\.d.*lsx_vmaddwod_q_du_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotr_b:.*vrotr\\.b.*lsx_vrotr_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotr_h:.*vrotr\\.h.*lsx_vrotr_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotr_w:.*vrotr\\.w.*lsx_vrotr_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotr_d:.*vrotr\\.d.*lsx_vrotr_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vadd_q:.*vadd\\.q.*lsx_vadd_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsub_q:.*vsub\\.q.*lsx_vsub_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vldrepl_b:.*vldrepl\\.b.*lsx_vldrepl_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vldrepl_h:.*vldrepl\\.h.*lsx_vldrepl_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vldrepl_w:.*vldrepl\\.w.*lsx_vldrepl_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vldrepl_d:.*vldrepl\\.d.*lsx_vldrepl_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmskgez_b:.*vmskgez\\.b.*lsx_vmskgez_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vmsknz_b:.*vmsknz\\.b.*lsx_vmsknz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_h_b:.*vexth\\.h\\.b.*lsx_vexth_h_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_w_h:.*vexth\\.w\\.h.*lsx_vexth_w_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_d_w:.*vexth\\.d\\.w.*lsx_vexth_d_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_q_d:.*vexth\\.q\\.d.*lsx_vexth_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_hu_bu:.*vexth\\.hu\\.bu.*lsx_vexth_hu_bu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_wu_hu:.*vexth\\.wu\\.hu.*lsx_vexth_wu_hu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_du_wu:.*vexth\\.du\\.wu.*lsx_vexth_du_wu" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vexth_qu_du:.*vexth\\.qu\\.du.*lsx_vexth_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotri_b:.*vrotri\\.b.*lsx_vrotri_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotri_h:.*vrotri\\.h.*lsx_vrotri_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotri_w:.*vrotri\\.w.*lsx_vrotri_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrotri_d:.*vrotri\\.d.*lsx_vrotri_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vextl_q_d:.*vextl\\.q\\.d.*lsx_vextl_q_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlni_b_h:.*vsrlni\\.b\\.h.*lsx_vsrlni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlni_h_w:.*vsrlni\\.h\\.w.*lsx_vsrlni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlni_w_d:.*vsrlni\\.w\\.d.*lsx_vsrlni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlni_d_q:.*vsrlni\\.d\\.q.*lsx_vsrlni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlrni_b_h:.*vsrlrni\\.b\\.h.*lsx_vsrlrni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlrni_h_w:.*vsrlrni\\.h\\.w.*lsx_vsrlrni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlrni_w_d:.*vsrlrni\\.w\\.d.*lsx_vsrlrni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrlrni_d_q:.*vsrlrni\\.d\\.q.*lsx_vsrlrni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_b_h:.*vssrlni\\.b\\.h.*lsx_vssrlni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_h_w:.*vssrlni\\.h\\.w.*lsx_vssrlni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_w_d:.*vssrlni\\.w\\.d.*lsx_vssrlni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_d_q:.*vssrlni\\.d\\.q.*lsx_vssrlni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_bu_h:.*vssrlni\\.bu\\.h.*lsx_vssrlni_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_hu_w:.*vssrlni\\.hu\\.w.*lsx_vssrlni_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_wu_d:.*vssrlni\\.wu\\.d.*lsx_vssrlni_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlni_du_q:.*vssrlni\\.du\\.q.*lsx_vssrlni_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_b_h:.*vssrlrni\\.b\\.h.*lsx_vssrlrni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_h_w:.*vssrlrni\\.h\\.w.*lsx_vssrlrni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_w_d:.*vssrlrni\\.w\\.d.*lsx_vssrlrni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_d_q:.*vssrlrni\\.d\\.q.*lsx_vssrlrni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_bu_h:.*vssrlrni\\.bu\\.h.*lsx_vssrlrni_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_hu_w:.*vssrlrni\\.hu\\.w.*lsx_vssrlrni_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_wu_d:.*vssrlrni\\.wu\\.d.*lsx_vssrlrni_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrni_du_q:.*vssrlrni\\.du\\.q.*lsx_vssrlrni_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrani_b_h:.*vsrani\\.b\\.h.*lsx_vsrani_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrani_h_w:.*vsrani\\.h\\.w.*lsx_vsrani_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrani_w_d:.*vsrani\\.w\\.d.*lsx_vsrani_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrani_d_q:.*vsrani\\.d\\.q.*lsx_vsrani_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrarni_b_h:.*vsrarni\\.b\\.h.*lsx_vsrarni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrarni_h_w:.*vsrarni\\.h\\.w.*lsx_vsrarni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrarni_w_d:.*vsrarni\\.w\\.d.*lsx_vsrarni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vsrarni_d_q:.*vsrarni\\.d\\.q.*lsx_vsrarni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_b_h:.*vssrani\\.b\\.h.*lsx_vssrani_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_h_w:.*vssrani\\.h\\.w.*lsx_vssrani_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_w_d:.*vssrani\\.w\\.d.*lsx_vssrani_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_d_q:.*vssrani\\.d\\.q.*lsx_vssrani_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_bu_h:.*vssrani\\.bu\\.h.*lsx_vssrani_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_hu_w:.*vssrani\\.hu\\.w.*lsx_vssrani_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_wu_d:.*vssrani\\.wu\\.d.*lsx_vssrani_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrani_du_q:.*vssrani\\.du\\.q.*lsx_vssrani_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_b_h:.*vssrarni\\.b\\.h.*lsx_vssrarni_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_h_w:.*vssrarni\\.h\\.w.*lsx_vssrarni_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_w_d:.*vssrarni\\.w\\.d.*lsx_vssrarni_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_d_q:.*vssrarni\\.d\\.q.*lsx_vssrarni_d_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_bu_h:.*vssrarni\\.bu\\.h.*lsx_vssrarni_bu_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_hu_w:.*vssrarni\\.hu\\.w.*lsx_vssrarni_hu_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_wu_d:.*vssrarni\\.wu\\.d.*lsx_vssrarni_wu_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrarni_du_q:.*vssrarni\\.du\\.q.*lsx_vssrarni_du_q" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vpermi_w:.*vpermi\\.w.*lsx_vpermi_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vld:.*vld.*lsx_vld" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vst:.*vst.*lsx_vst" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrn_b_h:.*vssrlrn\\.b\\.h.*lsx_vssrlrn_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrn_h_w:.*vssrlrn\\.h\\.w.*lsx_vssrlrn_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrlrn_w_d:.*vssrlrn\\.w\\.d.*lsx_vssrlrn_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrln_b_h:.*vssrln\\.b\\.h.*lsx_vssrln_b_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrln_h_w:.*vssrln\\.h\\.w.*lsx_vssrln_h_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vssrln_w_d:.*vssrln\\.w\\.d.*lsx_vssrln_w_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vorn_v:.*vorn\\.v.*lsx_vorn_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vldi:.*vldi.*lsx_vldi" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vshuf_b:.*vshuf\\.b.*lsx_vshuf_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vldx:.*vldx.*lsx_vldx" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vstx:.*vstx.*lsx_vstx" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vextl_qu_du:.*vextl\\.qu\\.du.*lsx_vextl_qu_du" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bnz_b:.*vsetanyeqz\\.b.*lsx_bnz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bnz_d:.*vsetanyeqz\\.d.*lsx_bnz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bnz_h:.*vsetanyeqz\\.h.*lsx_bnz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bnz_v:.*vseteqz\\.v.*lsx_bnz_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bnz_w:.*vsetanyeqz\\.w.*lsx_bnz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bz_b:.*vsetallnez\\.b.*lsx_bz_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bz_d:.*vsetallnez\\.d.*lsx_bz_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bz_h:.*vsetallnez\\.h.*lsx_bz_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bz_v:.*vsetnez\\.v.*lsx_bz_v" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_bz_w:.*vsetallnez\\.w.*lsx_bz_w" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_caf_d:.*vfcmp\\.caf\\.d.*lsx_vfcmp_caf_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_caf_s:.*vfcmp\\.caf\\.s.*lsx_vfcmp_caf_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_ceq_d:.*vfcmp\\.ceq\\.d.*lsx_vfcmp_ceq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_ceq_s:.*vfcmp\\.ceq\\.s.*lsx_vfcmp_ceq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cle_d:.*vfcmp\\.cle\\.d.*lsx_vfcmp_cle_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cle_s:.*vfcmp\\.cle\\.s.*lsx_vfcmp_cle_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_clt_d:.*vfcmp\\.clt\\.d.*lsx_vfcmp_clt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_clt_s:.*vfcmp\\.clt\\.s.*lsx_vfcmp_clt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cne_d:.*vfcmp\\.cne\\.d.*lsx_vfcmp_cne_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cne_s:.*vfcmp\\.cne\\.s.*lsx_vfcmp_cne_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cor_d:.*vfcmp\\.cor\\.d.*lsx_vfcmp_cor_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cor_s:.*vfcmp\\.cor\\.s.*lsx_vfcmp_cor_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cueq_d:.*vfcmp\\.cueq\\.d.*lsx_vfcmp_cueq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cueq_s:.*vfcmp\\.cueq\\.s.*lsx_vfcmp_cueq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cule_d:.*vfcmp\\.cule\\.d.*lsx_vfcmp_cule_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cule_s:.*vfcmp\\.cule\\.s.*lsx_vfcmp_cule_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cult_d:.*vfcmp\\.cult\\.d.*lsx_vfcmp_cult_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cult_s:.*vfcmp\\.cult\\.s.*lsx_vfcmp_cult_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cun_d:.*vfcmp\\.cun\\.d.*lsx_vfcmp_cun_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cune_d:.*vfcmp\\.cune\\.d.*lsx_vfcmp_cune_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cune_s:.*vfcmp\\.cune\\.s.*lsx_vfcmp_cune_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_cun_s:.*vfcmp\\.cun\\.s.*lsx_vfcmp_cun_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_saf_d:.*vfcmp\\.saf\\.d.*lsx_vfcmp_saf_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_saf_s:.*vfcmp\\.saf\\.s.*lsx_vfcmp_saf_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_seq_d:.*vfcmp\\.seq\\.d.*lsx_vfcmp_seq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_seq_s:.*vfcmp\\.seq\\.s.*lsx_vfcmp_seq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sle_d:.*vfcmp\\.sle\\.d.*lsx_vfcmp_sle_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sle_s:.*vfcmp\\.sle\\.s.*lsx_vfcmp_sle_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_slt_d:.*vfcmp\\.slt\\.d.*lsx_vfcmp_slt_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_slt_s:.*vfcmp\\.slt\\.s.*lsx_vfcmp_slt_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sne_d:.*vfcmp\\.sne\\.d.*lsx_vfcmp_sne_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sne_s:.*vfcmp\\.sne\\.s.*lsx_vfcmp_sne_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sor_d:.*vfcmp\\.sor\\.d.*lsx_vfcmp_sor_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sor_s:.*vfcmp\\.sor\\.s.*lsx_vfcmp_sor_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sueq_d:.*vfcmp\\.sueq\\.d.*lsx_vfcmp_sueq_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sueq_s:.*vfcmp\\.sueq\\.s.*lsx_vfcmp_sueq_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sule_d:.*vfcmp\\.sule\\.d.*lsx_vfcmp_sule_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sule_s:.*vfcmp\\.sule\\.s.*lsx_vfcmp_sule_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sult_d:.*vfcmp\\.sult\\.d.*lsx_vfcmp_sult_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sult_s:.*vfcmp\\.sult\\.s.*lsx_vfcmp_sult_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sun_d:.*vfcmp\\.sun\\.d.*lsx_vfcmp_sun_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sune_d:.*vfcmp\\.sune\\.d.*lsx_vfcmp_sune_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sune_s:.*vfcmp\\.sune\\.s.*lsx_vfcmp_sune_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vfcmp_sun_s:.*vfcmp\\.sun\\.s.*lsx_vfcmp_sun_s" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrepli_b:.*vrepli\\.b.*lsx_vrepli_b" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrepli_d:.*vrepli\\.d.*lsx_vrepli_d" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrepli_h:.*vrepli\\.h.*lsx_vrepli_h" 1 } } */ ++/* { dg-final { scan-assembler-times "lsx_vrepli_w:.*vrepli\\.w.*lsx_vrepli_w" 1 } } */ ++ ++typedef signed char v16i8 __attribute__ ((vector_size (16), aligned (16))); ++typedef signed char v16i8_b __attribute__ ((vector_size (16), aligned (1))); ++typedef unsigned char v16u8 __attribute__ ((vector_size (16), aligned (16))); ++typedef unsigned char v16u8_b __attribute__ ((vector_size (16), aligned (1))); ++typedef short v8i16 __attribute__ ((vector_size (16), aligned (16))); ++typedef short v8i16_h __attribute__ ((vector_size (16), aligned (2))); ++typedef unsigned short v8u16 __attribute__ ((vector_size (16), aligned (16))); ++typedef unsigned short v8u16_h __attribute__ ((vector_size (16), aligned (2))); ++typedef int v4i32 __attribute__ ((vector_size (16), aligned (16))); ++typedef int v4i32_w __attribute__ ((vector_size (16), aligned (4))); ++typedef unsigned int v4u32 __attribute__ ((vector_size (16), aligned (16))); ++typedef unsigned int v4u32_w __attribute__ ((vector_size (16), aligned (4))); ++typedef long long v2i64 __attribute__ ((vector_size (16), aligned (16))); ++typedef long long v2i64_d __attribute__ ((vector_size (16), aligned (8))); ++typedef unsigned long long v2u64 ++ __attribute__ ((vector_size (16), aligned (16))); ++typedef unsigned long long v2u64_d ++ __attribute__ ((vector_size (16), aligned (8))); ++typedef float v4f32 __attribute__ ((vector_size (16), aligned (16))); ++typedef float v4f32_w __attribute__ ((vector_size (16), aligned (4))); ++typedef double v2f64 __attribute__ ((vector_size (16), aligned (16))); ++typedef double v2f64_d __attribute__ ((vector_size (16), aligned (8))); ++ ++typedef long long __m128i ++ __attribute__ ((__vector_size__ (16), __may_alias__)); ++typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__)); ++typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__)); ++ ++v16i8 ++__lsx_vsll_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsll_b (_1, _2); ++} ++v8i16 ++__lsx_vsll_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsll_h (_1, _2); ++} ++v4i32 ++__lsx_vsll_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsll_w (_1, _2); ++} ++v2i64 ++__lsx_vsll_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsll_d (_1, _2); ++} ++v16i8 ++__lsx_vslli_b (v16i8 _1) ++{ ++ return __builtin_lsx_vslli_b (_1, 1); ++} ++v8i16 ++__lsx_vslli_h (v8i16 _1) ++{ ++ return __builtin_lsx_vslli_h (_1, 1); ++} ++v4i32 ++__lsx_vslli_w (v4i32 _1) ++{ ++ return __builtin_lsx_vslli_w (_1, 1); ++} ++v2i64 ++__lsx_vslli_d (v2i64 _1) ++{ ++ return __builtin_lsx_vslli_d (_1, 1); ++} ++v16i8 ++__lsx_vsra_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsra_b (_1, _2); ++} ++v8i16 ++__lsx_vsra_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsra_h (_1, _2); ++} ++v4i32 ++__lsx_vsra_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsra_w (_1, _2); ++} ++v2i64 ++__lsx_vsra_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsra_d (_1, _2); ++} ++v16i8 ++__lsx_vsrai_b (v16i8 _1) ++{ ++ return __builtin_lsx_vsrai_b (_1, 1); ++} ++v8i16 ++__lsx_vsrai_h (v8i16 _1) ++{ ++ return __builtin_lsx_vsrai_h (_1, 1); ++} ++v4i32 ++__lsx_vsrai_w (v4i32 _1) ++{ ++ return __builtin_lsx_vsrai_w (_1, 1); ++} ++v2i64 ++__lsx_vsrai_d (v2i64 _1) ++{ ++ return __builtin_lsx_vsrai_d (_1, 1); ++} ++v16i8 ++__lsx_vsrar_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsrar_b (_1, _2); ++} ++v8i16 ++__lsx_vsrar_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrar_h (_1, _2); ++} ++v4i32 ++__lsx_vsrar_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrar_w (_1, _2); ++} ++v2i64 ++__lsx_vsrar_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrar_d (_1, _2); ++} ++v16i8 ++__lsx_vsrari_b (v16i8 _1) ++{ ++ return __builtin_lsx_vsrari_b (_1, 1); ++} ++v8i16 ++__lsx_vsrari_h (v8i16 _1) ++{ ++ return __builtin_lsx_vsrari_h (_1, 1); ++} ++v4i32 ++__lsx_vsrari_w (v4i32 _1) ++{ ++ return __builtin_lsx_vsrari_w (_1, 1); ++} ++v2i64 ++__lsx_vsrari_d (v2i64 _1) ++{ ++ return __builtin_lsx_vsrari_d (_1, 1); ++} ++v16i8 ++__lsx_vsrl_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsrl_b (_1, _2); ++} ++v8i16 ++__lsx_vsrl_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrl_h (_1, _2); ++} ++v4i32 ++__lsx_vsrl_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrl_w (_1, _2); ++} ++v2i64 ++__lsx_vsrl_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrl_d (_1, _2); ++} ++v16i8 ++__lsx_vsrli_b (v16i8 _1) ++{ ++ return __builtin_lsx_vsrli_b (_1, 1); ++} ++v8i16 ++__lsx_vsrli_h (v8i16 _1) ++{ ++ return __builtin_lsx_vsrli_h (_1, 1); ++} ++v4i32 ++__lsx_vsrli_w (v4i32 _1) ++{ ++ return __builtin_lsx_vsrli_w (_1, 1); ++} ++v2i64 ++__lsx_vsrli_d (v2i64 _1) ++{ ++ return __builtin_lsx_vsrli_d (_1, 1); ++} ++v16i8 ++__lsx_vsrlr_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsrlr_b (_1, _2); ++} ++v8i16 ++__lsx_vsrlr_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrlr_h (_1, _2); ++} ++v4i32 ++__lsx_vsrlr_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrlr_w (_1, _2); ++} ++v2i64 ++__lsx_vsrlr_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrlr_d (_1, _2); ++} ++v16i8 ++__lsx_vsrlri_b (v16i8 _1) ++{ ++ return __builtin_lsx_vsrlri_b (_1, 1); ++} ++v8i16 ++__lsx_vsrlri_h (v8i16 _1) ++{ ++ return __builtin_lsx_vsrlri_h (_1, 1); ++} ++v4i32 ++__lsx_vsrlri_w (v4i32 _1) ++{ ++ return __builtin_lsx_vsrlri_w (_1, 1); ++} ++v2i64 ++__lsx_vsrlri_d (v2i64 _1) ++{ ++ return __builtin_lsx_vsrlri_d (_1, 1); ++} ++v16u8 ++__lsx_vbitclr_b (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vbitclr_b (_1, _2); ++} ++v8u16 ++__lsx_vbitclr_h (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vbitclr_h (_1, _2); ++} ++v4u32 ++__lsx_vbitclr_w (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vbitclr_w (_1, _2); ++} ++v2u64 ++__lsx_vbitclr_d (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vbitclr_d (_1, _2); ++} ++v16u8 ++__lsx_vbitclri_b (v16u8 _1) ++{ ++ return __builtin_lsx_vbitclri_b (_1, 1); ++} ++v8u16 ++__lsx_vbitclri_h (v8u16 _1) ++{ ++ return __builtin_lsx_vbitclri_h (_1, 1); ++} ++v4u32 ++__lsx_vbitclri_w (v4u32 _1) ++{ ++ return __builtin_lsx_vbitclri_w (_1, 1); ++} ++v2u64 ++__lsx_vbitclri_d (v2u64 _1) ++{ ++ return __builtin_lsx_vbitclri_d (_1, 1); ++} ++v16u8 ++__lsx_vbitset_b (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vbitset_b (_1, _2); ++} ++v8u16 ++__lsx_vbitset_h (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vbitset_h (_1, _2); ++} ++v4u32 ++__lsx_vbitset_w (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vbitset_w (_1, _2); ++} ++v2u64 ++__lsx_vbitset_d (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vbitset_d (_1, _2); ++} ++v16u8 ++__lsx_vbitseti_b (v16u8 _1) ++{ ++ return __builtin_lsx_vbitseti_b (_1, 1); ++} ++v8u16 ++__lsx_vbitseti_h (v8u16 _1) ++{ ++ return __builtin_lsx_vbitseti_h (_1, 1); ++} ++v4u32 ++__lsx_vbitseti_w (v4u32 _1) ++{ ++ return __builtin_lsx_vbitseti_w (_1, 1); ++} ++v2u64 ++__lsx_vbitseti_d (v2u64 _1) ++{ ++ return __builtin_lsx_vbitseti_d (_1, 1); ++} ++v16u8 ++__lsx_vbitrev_b (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vbitrev_b (_1, _2); ++} ++v8u16 ++__lsx_vbitrev_h (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vbitrev_h (_1, _2); ++} ++v4u32 ++__lsx_vbitrev_w (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vbitrev_w (_1, _2); ++} ++v2u64 ++__lsx_vbitrev_d (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vbitrev_d (_1, _2); ++} ++v16u8 ++__lsx_vbitrevi_b (v16u8 _1) ++{ ++ return __builtin_lsx_vbitrevi_b (_1, 1); ++} ++v8u16 ++__lsx_vbitrevi_h (v8u16 _1) ++{ ++ return __builtin_lsx_vbitrevi_h (_1, 1); ++} ++v4u32 ++__lsx_vbitrevi_w (v4u32 _1) ++{ ++ return __builtin_lsx_vbitrevi_w (_1, 1); ++} ++v2u64 ++__lsx_vbitrevi_d (v2u64 _1) ++{ ++ return __builtin_lsx_vbitrevi_d (_1, 1); ++} ++v16i8 ++__lsx_vadd_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vadd_b (_1, _2); ++} ++v8i16 ++__lsx_vadd_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vadd_h (_1, _2); ++} ++v4i32 ++__lsx_vadd_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vadd_w (_1, _2); ++} ++v2i64 ++__lsx_vadd_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vadd_d (_1, _2); ++} ++v16i8 ++__lsx_vaddi_bu (v16i8 _1) ++{ ++ return __builtin_lsx_vaddi_bu (_1, 1); ++} ++v8i16 ++__lsx_vaddi_hu (v8i16 _1) ++{ ++ return __builtin_lsx_vaddi_hu (_1, 1); ++} ++v4i32 ++__lsx_vaddi_wu (v4i32 _1) ++{ ++ return __builtin_lsx_vaddi_wu (_1, 1); ++} ++v2i64 ++__lsx_vaddi_du (v2i64 _1) ++{ ++ return __builtin_lsx_vaddi_du (_1, 1); ++} ++v16i8 ++__lsx_vsub_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsub_b (_1, _2); ++} ++v8i16 ++__lsx_vsub_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsub_h (_1, _2); ++} ++v4i32 ++__lsx_vsub_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsub_w (_1, _2); ++} ++v2i64 ++__lsx_vsub_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsub_d (_1, _2); ++} ++v16i8 ++__lsx_vsubi_bu (v16i8 _1) ++{ ++ return __builtin_lsx_vsubi_bu (_1, 1); ++} ++v8i16 ++__lsx_vsubi_hu (v8i16 _1) ++{ ++ return __builtin_lsx_vsubi_hu (_1, 1); ++} ++v4i32 ++__lsx_vsubi_wu (v4i32 _1) ++{ ++ return __builtin_lsx_vsubi_wu (_1, 1); ++} ++v2i64 ++__lsx_vsubi_du (v2i64 _1) ++{ ++ return __builtin_lsx_vsubi_du (_1, 1); ++} ++v16i8 ++__lsx_vmax_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmax_b (_1, _2); ++} ++v8i16 ++__lsx_vmax_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmax_h (_1, _2); ++} ++v4i32 ++__lsx_vmax_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmax_w (_1, _2); ++} ++v2i64 ++__lsx_vmax_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmax_d (_1, _2); ++} ++v16i8 ++__lsx_vmaxi_b (v16i8 _1) ++{ ++ return __builtin_lsx_vmaxi_b (_1, 1); ++} ++v8i16 ++__lsx_vmaxi_h (v8i16 _1) ++{ ++ return __builtin_lsx_vmaxi_h (_1, 1); ++} ++v4i32 ++__lsx_vmaxi_w (v4i32 _1) ++{ ++ return __builtin_lsx_vmaxi_w (_1, 1); ++} ++v2i64 ++__lsx_vmaxi_d (v2i64 _1) ++{ ++ return __builtin_lsx_vmaxi_d (_1, 1); ++} ++v16u8 ++__lsx_vmax_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vmax_bu (_1, _2); ++} ++v8u16 ++__lsx_vmax_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vmax_hu (_1, _2); ++} ++v4u32 ++__lsx_vmax_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vmax_wu (_1, _2); ++} ++v2u64 ++__lsx_vmax_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vmax_du (_1, _2); ++} ++v16u8 ++__lsx_vmaxi_bu (v16u8 _1) ++{ ++ return __builtin_lsx_vmaxi_bu (_1, 1); ++} ++v8u16 ++__lsx_vmaxi_hu (v8u16 _1) ++{ ++ return __builtin_lsx_vmaxi_hu (_1, 1); ++} ++v4u32 ++__lsx_vmaxi_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vmaxi_wu (_1, 1); ++} ++v2u64 ++__lsx_vmaxi_du (v2u64 _1) ++{ ++ return __builtin_lsx_vmaxi_du (_1, 1); ++} ++v16i8 ++__lsx_vmin_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmin_b (_1, _2); ++} ++v8i16 ++__lsx_vmin_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmin_h (_1, _2); ++} ++v4i32 ++__lsx_vmin_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmin_w (_1, _2); ++} ++v2i64 ++__lsx_vmin_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmin_d (_1, _2); ++} ++v16i8 ++__lsx_vmini_b (v16i8 _1) ++{ ++ return __builtin_lsx_vmini_b (_1, 1); ++} ++v8i16 ++__lsx_vmini_h (v8i16 _1) ++{ ++ return __builtin_lsx_vmini_h (_1, 1); ++} ++v4i32 ++__lsx_vmini_w (v4i32 _1) ++{ ++ return __builtin_lsx_vmini_w (_1, 1); ++} ++v2i64 ++__lsx_vmini_d (v2i64 _1) ++{ ++ return __builtin_lsx_vmini_d (_1, 1); ++} ++v16u8 ++__lsx_vmin_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vmin_bu (_1, _2); ++} ++v8u16 ++__lsx_vmin_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vmin_hu (_1, _2); ++} ++v4u32 ++__lsx_vmin_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vmin_wu (_1, _2); ++} ++v2u64 ++__lsx_vmin_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vmin_du (_1, _2); ++} ++v16u8 ++__lsx_vmini_bu (v16u8 _1) ++{ ++ return __builtin_lsx_vmini_bu (_1, 1); ++} ++v8u16 ++__lsx_vmini_hu (v8u16 _1) ++{ ++ return __builtin_lsx_vmini_hu (_1, 1); ++} ++v4u32 ++__lsx_vmini_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vmini_wu (_1, 1); ++} ++v2u64 ++__lsx_vmini_du (v2u64 _1) ++{ ++ return __builtin_lsx_vmini_du (_1, 1); ++} ++v16i8 ++__lsx_vseq_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vseq_b (_1, _2); ++} ++v8i16 ++__lsx_vseq_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vseq_h (_1, _2); ++} ++v4i32 ++__lsx_vseq_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vseq_w (_1, _2); ++} ++v2i64 ++__lsx_vseq_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vseq_d (_1, _2); ++} ++v16i8 ++__lsx_vseqi_b (v16i8 _1) ++{ ++ return __builtin_lsx_vseqi_b (_1, 1); ++} ++v8i16 ++__lsx_vseqi_h (v8i16 _1) ++{ ++ return __builtin_lsx_vseqi_h (_1, 1); ++} ++v4i32 ++__lsx_vseqi_w (v4i32 _1) ++{ ++ return __builtin_lsx_vseqi_w (_1, 1); ++} ++v2i64 ++__lsx_vseqi_d (v2i64 _1) ++{ ++ return __builtin_lsx_vseqi_d (_1, 1); ++} ++v16i8 ++__lsx_vslti_b (v16i8 _1) ++{ ++ return __builtin_lsx_vslti_b (_1, 1); ++} ++v16i8 ++__lsx_vslt_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vslt_b (_1, _2); ++} ++v8i16 ++__lsx_vslt_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vslt_h (_1, _2); ++} ++v4i32 ++__lsx_vslt_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vslt_w (_1, _2); ++} ++v2i64 ++__lsx_vslt_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vslt_d (_1, _2); ++} ++v8i16 ++__lsx_vslti_h (v8i16 _1) ++{ ++ return __builtin_lsx_vslti_h (_1, 1); ++} ++v4i32 ++__lsx_vslti_w (v4i32 _1) ++{ ++ return __builtin_lsx_vslti_w (_1, 1); ++} ++v2i64 ++__lsx_vslti_d (v2i64 _1) ++{ ++ return __builtin_lsx_vslti_d (_1, 1); ++} ++v16i8 ++__lsx_vslt_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vslt_bu (_1, _2); ++} ++v8i16 ++__lsx_vslt_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vslt_hu (_1, _2); ++} ++v4i32 ++__lsx_vslt_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vslt_wu (_1, _2); ++} ++v2i64 ++__lsx_vslt_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vslt_du (_1, _2); ++} ++v16i8 ++__lsx_vslti_bu (v16u8 _1) ++{ ++ return __builtin_lsx_vslti_bu (_1, 1); ++} ++v8i16 ++__lsx_vslti_hu (v8u16 _1) ++{ ++ return __builtin_lsx_vslti_hu (_1, 1); ++} ++v4i32 ++__lsx_vslti_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vslti_wu (_1, 1); ++} ++v2i64 ++__lsx_vslti_du (v2u64 _1) ++{ ++ return __builtin_lsx_vslti_du (_1, 1); ++} ++v16i8 ++__lsx_vsle_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsle_b (_1, _2); ++} ++v8i16 ++__lsx_vsle_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsle_h (_1, _2); ++} ++v4i32 ++__lsx_vsle_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsle_w (_1, _2); ++} ++v2i64 ++__lsx_vsle_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsle_d (_1, _2); ++} ++v16i8 ++__lsx_vslei_b (v16i8 _1) ++{ ++ return __builtin_lsx_vslei_b (_1, 1); ++} ++v8i16 ++__lsx_vslei_h (v8i16 _1) ++{ ++ return __builtin_lsx_vslei_h (_1, 1); ++} ++v4i32 ++__lsx_vslei_w (v4i32 _1) ++{ ++ return __builtin_lsx_vslei_w (_1, 1); ++} ++v2i64 ++__lsx_vslei_d (v2i64 _1) ++{ ++ return __builtin_lsx_vslei_d (_1, 1); ++} ++v16i8 ++__lsx_vsle_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vsle_bu (_1, _2); ++} ++v8i16 ++__lsx_vsle_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vsle_hu (_1, _2); ++} ++v4i32 ++__lsx_vsle_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vsle_wu (_1, _2); ++} ++v2i64 ++__lsx_vsle_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vsle_du (_1, _2); ++} ++v16i8 ++__lsx_vslei_bu (v16u8 _1) ++{ ++ return __builtin_lsx_vslei_bu (_1, 1); ++} ++v8i16 ++__lsx_vslei_hu (v8u16 _1) ++{ ++ return __builtin_lsx_vslei_hu (_1, 1); ++} ++v4i32 ++__lsx_vslei_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vslei_wu (_1, 1); ++} ++v2i64 ++__lsx_vslei_du (v2u64 _1) ++{ ++ return __builtin_lsx_vslei_du (_1, 1); ++} ++v16i8 ++__lsx_vsat_b (v16i8 _1) ++{ ++ return __builtin_lsx_vsat_b (_1, 1); ++} ++v8i16 ++__lsx_vsat_h (v8i16 _1) ++{ ++ return __builtin_lsx_vsat_h (_1, 1); ++} ++v4i32 ++__lsx_vsat_w (v4i32 _1) ++{ ++ return __builtin_lsx_vsat_w (_1, 1); ++} ++v2i64 ++__lsx_vsat_d (v2i64 _1) ++{ ++ return __builtin_lsx_vsat_d (_1, 1); ++} ++v16u8 ++__lsx_vsat_bu (v16u8 _1) ++{ ++ return __builtin_lsx_vsat_bu (_1, 1); ++} ++v8u16 ++__lsx_vsat_hu (v8u16 _1) ++{ ++ return __builtin_lsx_vsat_hu (_1, 1); ++} ++v4u32 ++__lsx_vsat_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vsat_wu (_1, 1); ++} ++v2u64 ++__lsx_vsat_du (v2u64 _1) ++{ ++ return __builtin_lsx_vsat_du (_1, 1); ++} ++v16i8 ++__lsx_vadda_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vadda_b (_1, _2); ++} ++v8i16 ++__lsx_vadda_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vadda_h (_1, _2); ++} ++v4i32 ++__lsx_vadda_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vadda_w (_1, _2); ++} ++v2i64 ++__lsx_vadda_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vadda_d (_1, _2); ++} ++v16i8 ++__lsx_vsadd_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsadd_b (_1, _2); ++} ++v8i16 ++__lsx_vsadd_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsadd_h (_1, _2); ++} ++v4i32 ++__lsx_vsadd_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsadd_w (_1, _2); ++} ++v2i64 ++__lsx_vsadd_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsadd_d (_1, _2); ++} ++v16u8 ++__lsx_vsadd_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vsadd_bu (_1, _2); ++} ++v8u16 ++__lsx_vsadd_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vsadd_hu (_1, _2); ++} ++v4u32 ++__lsx_vsadd_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vsadd_wu (_1, _2); ++} ++v2u64 ++__lsx_vsadd_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vsadd_du (_1, _2); ++} ++v16i8 ++__lsx_vavg_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vavg_b (_1, _2); ++} ++v8i16 ++__lsx_vavg_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vavg_h (_1, _2); ++} ++v4i32 ++__lsx_vavg_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vavg_w (_1, _2); ++} ++v2i64 ++__lsx_vavg_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vavg_d (_1, _2); ++} ++v16u8 ++__lsx_vavg_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vavg_bu (_1, _2); ++} ++v8u16 ++__lsx_vavg_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vavg_hu (_1, _2); ++} ++v4u32 ++__lsx_vavg_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vavg_wu (_1, _2); ++} ++v2u64 ++__lsx_vavg_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vavg_du (_1, _2); ++} ++v16i8 ++__lsx_vavgr_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vavgr_b (_1, _2); ++} ++v8i16 ++__lsx_vavgr_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vavgr_h (_1, _2); ++} ++v4i32 ++__lsx_vavgr_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vavgr_w (_1, _2); ++} ++v2i64 ++__lsx_vavgr_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vavgr_d (_1, _2); ++} ++v16u8 ++__lsx_vavgr_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vavgr_bu (_1, _2); ++} ++v8u16 ++__lsx_vavgr_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vavgr_hu (_1, _2); ++} ++v4u32 ++__lsx_vavgr_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vavgr_wu (_1, _2); ++} ++v2u64 ++__lsx_vavgr_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vavgr_du (_1, _2); ++} ++v16i8 ++__lsx_vssub_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssub_b (_1, _2); ++} ++v8i16 ++__lsx_vssub_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssub_h (_1, _2); ++} ++v4i32 ++__lsx_vssub_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssub_w (_1, _2); ++} ++v2i64 ++__lsx_vssub_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssub_d (_1, _2); ++} ++v16u8 ++__lsx_vssub_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vssub_bu (_1, _2); ++} ++v8u16 ++__lsx_vssub_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vssub_hu (_1, _2); ++} ++v4u32 ++__lsx_vssub_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vssub_wu (_1, _2); ++} ++v2u64 ++__lsx_vssub_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vssub_du (_1, _2); ++} ++v16i8 ++__lsx_vabsd_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vabsd_b (_1, _2); ++} ++v8i16 ++__lsx_vabsd_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vabsd_h (_1, _2); ++} ++v4i32 ++__lsx_vabsd_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vabsd_w (_1, _2); ++} ++v2i64 ++__lsx_vabsd_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vabsd_d (_1, _2); ++} ++v16u8 ++__lsx_vabsd_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vabsd_bu (_1, _2); ++} ++v8u16 ++__lsx_vabsd_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vabsd_hu (_1, _2); ++} ++v4u32 ++__lsx_vabsd_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vabsd_wu (_1, _2); ++} ++v2u64 ++__lsx_vabsd_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vabsd_du (_1, _2); ++} ++v16i8 ++__lsx_vmul_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmul_b (_1, _2); ++} ++v8i16 ++__lsx_vmul_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmul_h (_1, _2); ++} ++v4i32 ++__lsx_vmul_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmul_w (_1, _2); ++} ++v2i64 ++__lsx_vmul_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmul_d (_1, _2); ++} ++v16i8 ++__lsx_vmadd_b (v16i8 _1, v16i8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vmadd_b (_1, _2, _3); ++} ++v8i16 ++__lsx_vmadd_h (v8i16 _1, v8i16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vmadd_h (_1, _2, _3); ++} ++v4i32 ++__lsx_vmadd_w (v4i32 _1, v4i32 _2, v4i32 _3) ++{ ++ return __builtin_lsx_vmadd_w (_1, _2, _3); ++} ++v2i64 ++__lsx_vmadd_d (v2i64 _1, v2i64 _2, v2i64 _3) ++{ ++ return __builtin_lsx_vmadd_d (_1, _2, _3); ++} ++v16i8 ++__lsx_vmsub_b (v16i8 _1, v16i8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vmsub_b (_1, _2, _3); ++} ++v8i16 ++__lsx_vmsub_h (v8i16 _1, v8i16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vmsub_h (_1, _2, _3); ++} ++v4i32 ++__lsx_vmsub_w (v4i32 _1, v4i32 _2, v4i32 _3) ++{ ++ return __builtin_lsx_vmsub_w (_1, _2, _3); ++} ++v2i64 ++__lsx_vmsub_d (v2i64 _1, v2i64 _2, v2i64 _3) ++{ ++ return __builtin_lsx_vmsub_d (_1, _2, _3); ++} ++v16i8 ++__lsx_vdiv_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vdiv_b (_1, _2); ++} ++v8i16 ++__lsx_vdiv_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vdiv_h (_1, _2); ++} ++v4i32 ++__lsx_vdiv_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vdiv_w (_1, _2); ++} ++v2i64 ++__lsx_vdiv_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vdiv_d (_1, _2); ++} ++v16u8 ++__lsx_vdiv_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vdiv_bu (_1, _2); ++} ++v8u16 ++__lsx_vdiv_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vdiv_hu (_1, _2); ++} ++v4u32 ++__lsx_vdiv_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vdiv_wu (_1, _2); ++} ++v2u64 ++__lsx_vdiv_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vdiv_du (_1, _2); ++} ++v8i16 ++__lsx_vhaddw_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vhaddw_h_b (_1, _2); ++} ++v4i32 ++__lsx_vhaddw_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vhaddw_w_h (_1, _2); ++} ++v2i64 ++__lsx_vhaddw_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vhaddw_d_w (_1, _2); ++} ++v8u16 ++__lsx_vhaddw_hu_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vhaddw_hu_bu (_1, _2); ++} ++v4u32 ++__lsx_vhaddw_wu_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vhaddw_wu_hu (_1, _2); ++} ++v2u64 ++__lsx_vhaddw_du_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vhaddw_du_wu (_1, _2); ++} ++v8i16 ++__lsx_vhsubw_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vhsubw_h_b (_1, _2); ++} ++v4i32 ++__lsx_vhsubw_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vhsubw_w_h (_1, _2); ++} ++v2i64 ++__lsx_vhsubw_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vhsubw_d_w (_1, _2); ++} ++v8i16 ++__lsx_vhsubw_hu_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vhsubw_hu_bu (_1, _2); ++} ++v4i32 ++__lsx_vhsubw_wu_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vhsubw_wu_hu (_1, _2); ++} ++v2i64 ++__lsx_vhsubw_du_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vhsubw_du_wu (_1, _2); ++} ++v16i8 ++__lsx_vmod_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmod_b (_1, _2); ++} ++v8i16 ++__lsx_vmod_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmod_h (_1, _2); ++} ++v4i32 ++__lsx_vmod_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmod_w (_1, _2); ++} ++v2i64 ++__lsx_vmod_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmod_d (_1, _2); ++} ++v16u8 ++__lsx_vmod_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vmod_bu (_1, _2); ++} ++v8u16 ++__lsx_vmod_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vmod_hu (_1, _2); ++} ++v4u32 ++__lsx_vmod_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vmod_wu (_1, _2); ++} ++v2u64 ++__lsx_vmod_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vmod_du (_1, _2); ++} ++v16i8 ++__lsx_vreplve_b (v16i8 _1, int _2) ++{ ++ return __builtin_lsx_vreplve_b (_1, _2); ++} ++v8i16 ++__lsx_vreplve_h (v8i16 _1, int _2) ++{ ++ return __builtin_lsx_vreplve_h (_1, _2); ++} ++v4i32 ++__lsx_vreplve_w (v4i32 _1, int _2) ++{ ++ return __builtin_lsx_vreplve_w (_1, _2); ++} ++v2i64 ++__lsx_vreplve_d (v2i64 _1, int _2) ++{ ++ return __builtin_lsx_vreplve_d (_1, _2); ++} ++v16i8 ++__lsx_vreplvei_b (v16i8 _1) ++{ ++ return __builtin_lsx_vreplvei_b (_1, 1); ++} ++v8i16 ++__lsx_vreplvei_h (v8i16 _1) ++{ ++ return __builtin_lsx_vreplvei_h (_1, 1); ++} ++v4i32 ++__lsx_vreplvei_w (v4i32 _1) ++{ ++ return __builtin_lsx_vreplvei_w (_1, 1); ++} ++v2i64 ++__lsx_vreplvei_d (v2i64 _1) ++{ ++ return __builtin_lsx_vreplvei_d (_1, 1); ++} ++v16i8 ++__lsx_vpickev_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vpickev_b (_1, _2); ++} ++v8i16 ++__lsx_vpickev_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vpickev_h (_1, _2); ++} ++v4i32 ++__lsx_vpickev_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vpickev_w (_1, _2); ++} ++v2i64 ++__lsx_vpickev_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vpickev_d (_1, _2); ++} ++v16i8 ++__lsx_vpickod_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vpickod_b (_1, _2); ++} ++v8i16 ++__lsx_vpickod_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vpickod_h (_1, _2); ++} ++v4i32 ++__lsx_vpickod_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vpickod_w (_1, _2); ++} ++v2i64 ++__lsx_vpickod_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vpickod_d (_1, _2); ++} ++v16i8 ++__lsx_vilvh_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vilvh_b (_1, _2); ++} ++v8i16 ++__lsx_vilvh_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vilvh_h (_1, _2); ++} ++v4i32 ++__lsx_vilvh_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vilvh_w (_1, _2); ++} ++v2i64 ++__lsx_vilvh_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vilvh_d (_1, _2); ++} ++v16i8 ++__lsx_vilvl_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vilvl_b (_1, _2); ++} ++v8i16 ++__lsx_vilvl_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vilvl_h (_1, _2); ++} ++v4i32 ++__lsx_vilvl_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vilvl_w (_1, _2); ++} ++v2i64 ++__lsx_vilvl_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vilvl_d (_1, _2); ++} ++v16i8 ++__lsx_vpackev_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vpackev_b (_1, _2); ++} ++v8i16 ++__lsx_vpackev_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vpackev_h (_1, _2); ++} ++v4i32 ++__lsx_vpackev_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vpackev_w (_1, _2); ++} ++v2i64 ++__lsx_vpackev_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vpackev_d (_1, _2); ++} ++v16i8 ++__lsx_vpackod_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vpackod_b (_1, _2); ++} ++v8i16 ++__lsx_vpackod_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vpackod_h (_1, _2); ++} ++v4i32 ++__lsx_vpackod_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vpackod_w (_1, _2); ++} ++v2i64 ++__lsx_vpackod_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vpackod_d (_1, _2); ++} ++v8i16 ++__lsx_vshuf_h (v8i16 _1, v8i16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vshuf_h (_1, _2, _3); ++} ++v4i32 ++__lsx_vshuf_w (v4i32 _1, v4i32 _2, v4i32 _3) ++{ ++ return __builtin_lsx_vshuf_w (_1, _2, _3); ++} ++v2i64 ++__lsx_vshuf_d (v2i64 _1, v2i64 _2, v2i64 _3) ++{ ++ return __builtin_lsx_vshuf_d (_1, _2, _3); ++} ++v16u8 ++__lsx_vand_v (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vand_v (_1, _2); ++} ++v16u8 ++__lsx_vandi_b (v16u8 _1) ++{ ++ return __builtin_lsx_vandi_b (_1, 1); ++} ++v16u8 ++__lsx_vor_v (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vor_v (_1, _2); ++} ++v16u8 ++__lsx_vori_b (v16u8 _1) ++{ ++ return __builtin_lsx_vori_b (_1, 1); ++} ++v16u8 ++__lsx_vnor_v (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vnor_v (_1, _2); ++} ++v16u8 ++__lsx_vnori_b (v16u8 _1) ++{ ++ return __builtin_lsx_vnori_b (_1, 1); ++} ++v16u8 ++__lsx_vxor_v (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vxor_v (_1, _2); ++} ++v16u8 ++__lsx_vxori_b (v16u8 _1) ++{ ++ return __builtin_lsx_vxori_b (_1, 1); ++} ++v16u8 ++__lsx_vbitsel_v (v16u8 _1, v16u8 _2, v16u8 _3) ++{ ++ return __builtin_lsx_vbitsel_v (_1, _2, _3); ++} ++v16u8 ++__lsx_vbitseli_b (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vbitseli_b (_1, _2, 1); ++} ++v16i8 ++__lsx_vshuf4i_b (v16i8 _1) ++{ ++ return __builtin_lsx_vshuf4i_b (_1, 1); ++} ++v8i16 ++__lsx_vshuf4i_h (v8i16 _1) ++{ ++ return __builtin_lsx_vshuf4i_h (_1, 1); ++} ++v4i32 ++__lsx_vshuf4i_w (v4i32 _1) ++{ ++ return __builtin_lsx_vshuf4i_w (_1, 1); ++} ++v16i8 ++__lsx_vreplgr2vr_b (int _1) ++{ ++ return __builtin_lsx_vreplgr2vr_b (_1); ++} ++v8i16 ++__lsx_vreplgr2vr_h (int _1) ++{ ++ return __builtin_lsx_vreplgr2vr_h (_1); ++} ++v4i32 ++__lsx_vreplgr2vr_w (int _1) ++{ ++ return __builtin_lsx_vreplgr2vr_w (_1); ++} ++v2i64 ++__lsx_vreplgr2vr_d (long _1) ++{ ++ return __builtin_lsx_vreplgr2vr_d (_1); ++} ++v16i8 ++__lsx_vpcnt_b (v16i8 _1) ++{ ++ return __builtin_lsx_vpcnt_b (_1); ++} ++v8i16 ++__lsx_vpcnt_h (v8i16 _1) ++{ ++ return __builtin_lsx_vpcnt_h (_1); ++} ++v4i32 ++__lsx_vpcnt_w (v4i32 _1) ++{ ++ return __builtin_lsx_vpcnt_w (_1); ++} ++v2i64 ++__lsx_vpcnt_d (v2i64 _1) ++{ ++ return __builtin_lsx_vpcnt_d (_1); ++} ++v16i8 ++__lsx_vclo_b (v16i8 _1) ++{ ++ return __builtin_lsx_vclo_b (_1); ++} ++v8i16 ++__lsx_vclo_h (v8i16 _1) ++{ ++ return __builtin_lsx_vclo_h (_1); ++} ++v4i32 ++__lsx_vclo_w (v4i32 _1) ++{ ++ return __builtin_lsx_vclo_w (_1); ++} ++v2i64 ++__lsx_vclo_d (v2i64 _1) ++{ ++ return __builtin_lsx_vclo_d (_1); ++} ++v16i8 ++__lsx_vclz_b (v16i8 _1) ++{ ++ return __builtin_lsx_vclz_b (_1); ++} ++v8i16 ++__lsx_vclz_h (v8i16 _1) ++{ ++ return __builtin_lsx_vclz_h (_1); ++} ++v4i32 ++__lsx_vclz_w (v4i32 _1) ++{ ++ return __builtin_lsx_vclz_w (_1); ++} ++v2i64 ++__lsx_vclz_d (v2i64 _1) ++{ ++ return __builtin_lsx_vclz_d (_1); ++} ++int ++__lsx_vpickve2gr_b (v16i8 _1) ++{ ++ return __builtin_lsx_vpickve2gr_b (_1, 1); ++} ++int ++__lsx_vpickve2gr_h (v8i16 _1) ++{ ++ return __builtin_lsx_vpickve2gr_h (_1, 1); ++} ++int ++__lsx_vpickve2gr_w (v4i32 _1) ++{ ++ return __builtin_lsx_vpickve2gr_w (_1, 1); ++} ++long ++__lsx_vpickve2gr_d (v2i64 _1) ++{ ++ return __builtin_lsx_vpickve2gr_d (_1, 1); ++} ++unsigned int ++__lsx_vpickve2gr_bu (v16i8 _1) ++{ ++ return __builtin_lsx_vpickve2gr_bu (_1, 1); ++} ++unsigned int ++__lsx_vpickve2gr_hu (v8i16 _1) ++{ ++ return __builtin_lsx_vpickve2gr_hu (_1, 1); ++} ++unsigned int ++__lsx_vpickve2gr_wu (v4i32 _1) ++{ ++ return __builtin_lsx_vpickve2gr_wu (_1, 1); ++} ++unsigned long int ++__lsx_vpickve2gr_du (v2i64 _1) ++{ ++ return __builtin_lsx_vpickve2gr_du (_1, 1); ++} ++v16i8 ++__lsx_vinsgr2vr_b (v16i8 _1) ++{ ++ return __builtin_lsx_vinsgr2vr_b (_1, 1, 1); ++} ++v8i16 ++__lsx_vinsgr2vr_h (v8i16 _1) ++{ ++ return __builtin_lsx_vinsgr2vr_h (_1, 1, 1); ++} ++v4i32 ++__lsx_vinsgr2vr_w (v4i32 _1) ++{ ++ return __builtin_lsx_vinsgr2vr_w (_1, 1, 1); ++} ++v2i64 ++__lsx_vinsgr2vr_d (v2i64 _1) ++{ ++ return __builtin_lsx_vinsgr2vr_d (_1, 1, 1); ++} ++v4f32 ++__lsx_vfadd_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfadd_s (_1, _2); ++} ++v2f64 ++__lsx_vfadd_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfadd_d (_1, _2); ++} ++v4f32 ++__lsx_vfsub_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfsub_s (_1, _2); ++} ++v2f64 ++__lsx_vfsub_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfsub_d (_1, _2); ++} ++v4f32 ++__lsx_vfmul_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfmul_s (_1, _2); ++} ++v2f64 ++__lsx_vfmul_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfmul_d (_1, _2); ++} ++v4f32 ++__lsx_vfdiv_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfdiv_s (_1, _2); ++} ++v2f64 ++__lsx_vfdiv_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfdiv_d (_1, _2); ++} ++v8i16 ++__lsx_vfcvt_h_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcvt_h_s (_1, _2); ++} ++v4f32 ++__lsx_vfcvt_s_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcvt_s_d (_1, _2); ++} ++v4f32 ++__lsx_vfmin_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfmin_s (_1, _2); ++} ++v2f64 ++__lsx_vfmin_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfmin_d (_1, _2); ++} ++v4f32 ++__lsx_vfmina_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfmina_s (_1, _2); ++} ++v2f64 ++__lsx_vfmina_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfmina_d (_1, _2); ++} ++v4f32 ++__lsx_vfmax_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfmax_s (_1, _2); ++} ++v2f64 ++__lsx_vfmax_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfmax_d (_1, _2); ++} ++v4f32 ++__lsx_vfmaxa_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfmaxa_s (_1, _2); ++} ++v2f64 ++__lsx_vfmaxa_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfmaxa_d (_1, _2); ++} ++v4i32 ++__lsx_vfclass_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfclass_s (_1); ++} ++v2i64 ++__lsx_vfclass_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfclass_d (_1); ++} ++v4f32 ++__lsx_vfsqrt_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfsqrt_s (_1); ++} ++v2f64 ++__lsx_vfsqrt_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfsqrt_d (_1); ++} ++v4f32 ++__lsx_vfrecip_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfrecip_s (_1); ++} ++v2f64 ++__lsx_vfrecip_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfrecip_d (_1); ++} ++v4f32 ++__lsx_vfrint_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfrint_s (_1); ++} ++v2f64 ++__lsx_vfrint_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfrint_d (_1); ++} ++v4f32 ++__lsx_vfrsqrt_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfrsqrt_s (_1); ++} ++v2f64 ++__lsx_vfrsqrt_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfrsqrt_d (_1); ++} ++v4f32 ++__lsx_vflogb_s (v4f32 _1) ++{ ++ return __builtin_lsx_vflogb_s (_1); ++} ++v2f64 ++__lsx_vflogb_d (v2f64 _1) ++{ ++ return __builtin_lsx_vflogb_d (_1); ++} ++v4f32 ++__lsx_vfcvth_s_h (v8i16 _1) ++{ ++ return __builtin_lsx_vfcvth_s_h (_1); ++} ++v2f64 ++__lsx_vfcvth_d_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfcvth_d_s (_1); ++} ++v4f32 ++__lsx_vfcvtl_s_h (v8i16 _1) ++{ ++ return __builtin_lsx_vfcvtl_s_h (_1); ++} ++v2f64 ++__lsx_vfcvtl_d_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfcvtl_d_s (_1); ++} ++v4i32 ++__lsx_vftint_w_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftint_w_s (_1); ++} ++v2i64 ++__lsx_vftint_l_d (v2f64 _1) ++{ ++ return __builtin_lsx_vftint_l_d (_1); ++} ++v4u32 ++__lsx_vftint_wu_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftint_wu_s (_1); ++} ++v2u64 ++__lsx_vftint_lu_d (v2f64 _1) ++{ ++ return __builtin_lsx_vftint_lu_d (_1); ++} ++v4i32 ++__lsx_vftintrz_w_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrz_w_s (_1); ++} ++v2i64 ++__lsx_vftintrz_l_d (v2f64 _1) ++{ ++ return __builtin_lsx_vftintrz_l_d (_1); ++} ++v4u32 ++__lsx_vftintrz_wu_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrz_wu_s (_1); ++} ++v2u64 ++__lsx_vftintrz_lu_d (v2f64 _1) ++{ ++ return __builtin_lsx_vftintrz_lu_d (_1); ++} ++v4f32 ++__lsx_vffint_s_w (v4i32 _1) ++{ ++ return __builtin_lsx_vffint_s_w (_1); ++} ++v2f64 ++__lsx_vffint_d_l (v2i64 _1) ++{ ++ return __builtin_lsx_vffint_d_l (_1); ++} ++v4f32 ++__lsx_vffint_s_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vffint_s_wu (_1); ++} ++v2f64 ++__lsx_vffint_d_lu (v2u64 _1) ++{ ++ return __builtin_lsx_vffint_d_lu (_1); ++} ++v16u8 ++__lsx_vandn_v (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vandn_v (_1, _2); ++} ++v16i8 ++__lsx_vneg_b (v16i8 _1) ++{ ++ return __builtin_lsx_vneg_b (_1); ++} ++v8i16 ++__lsx_vneg_h (v8i16 _1) ++{ ++ return __builtin_lsx_vneg_h (_1); ++} ++v4i32 ++__lsx_vneg_w (v4i32 _1) ++{ ++ return __builtin_lsx_vneg_w (_1); ++} ++v2i64 ++__lsx_vneg_d (v2i64 _1) ++{ ++ return __builtin_lsx_vneg_d (_1); ++} ++v16i8 ++__lsx_vmuh_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmuh_b (_1, _2); ++} ++v8i16 ++__lsx_vmuh_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmuh_h (_1, _2); ++} ++v4i32 ++__lsx_vmuh_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmuh_w (_1, _2); ++} ++v2i64 ++__lsx_vmuh_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmuh_d (_1, _2); ++} ++v16u8 ++__lsx_vmuh_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vmuh_bu (_1, _2); ++} ++v8u16 ++__lsx_vmuh_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vmuh_hu (_1, _2); ++} ++v4u32 ++__lsx_vmuh_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vmuh_wu (_1, _2); ++} ++v2u64 ++__lsx_vmuh_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vmuh_du (_1, _2); ++} ++v8i16 ++__lsx_vsllwil_h_b (v16i8 _1) ++{ ++ return __builtin_lsx_vsllwil_h_b (_1, 1); ++} ++v4i32 ++__lsx_vsllwil_w_h (v8i16 _1) ++{ ++ return __builtin_lsx_vsllwil_w_h (_1, 1); ++} ++v2i64 ++__lsx_vsllwil_d_w (v4i32 _1) ++{ ++ return __builtin_lsx_vsllwil_d_w (_1, 1); ++} ++v8u16 ++__lsx_vsllwil_hu_bu (v16u8 _1) ++{ ++ return __builtin_lsx_vsllwil_hu_bu (_1, 1); ++} ++v4u32 ++__lsx_vsllwil_wu_hu (v8u16 _1) ++{ ++ return __builtin_lsx_vsllwil_wu_hu (_1, 1); ++} ++v2u64 ++__lsx_vsllwil_du_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vsllwil_du_wu (_1, 1); ++} ++v16i8 ++__lsx_vsran_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsran_b_h (_1, _2); ++} ++v8i16 ++__lsx_vsran_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsran_h_w (_1, _2); ++} ++v4i32 ++__lsx_vsran_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsran_w_d (_1, _2); ++} ++v16i8 ++__lsx_vssran_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssran_b_h (_1, _2); ++} ++v8i16 ++__lsx_vssran_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssran_h_w (_1, _2); ++} ++v4i32 ++__lsx_vssran_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssran_w_d (_1, _2); ++} ++v16u8 ++__lsx_vssran_bu_h (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vssran_bu_h (_1, _2); ++} ++v8u16 ++__lsx_vssran_hu_w (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vssran_hu_w (_1, _2); ++} ++v4u32 ++__lsx_vssran_wu_d (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vssran_wu_d (_1, _2); ++} ++v16i8 ++__lsx_vsrarn_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrarn_b_h (_1, _2); ++} ++v8i16 ++__lsx_vsrarn_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrarn_h_w (_1, _2); ++} ++v4i32 ++__lsx_vsrarn_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrarn_w_d (_1, _2); ++} ++v16i8 ++__lsx_vssrarn_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrarn_b_h (_1, _2); ++} ++v8i16 ++__lsx_vssrarn_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrarn_h_w (_1, _2); ++} ++v4i32 ++__lsx_vssrarn_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrarn_w_d (_1, _2); ++} ++v16u8 ++__lsx_vssrarn_bu_h (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vssrarn_bu_h (_1, _2); ++} ++v8u16 ++__lsx_vssrarn_hu_w (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vssrarn_hu_w (_1, _2); ++} ++v4u32 ++__lsx_vssrarn_wu_d (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vssrarn_wu_d (_1, _2); ++} ++v16i8 ++__lsx_vsrln_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrln_b_h (_1, _2); ++} ++v8i16 ++__lsx_vsrln_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrln_h_w (_1, _2); ++} ++v4i32 ++__lsx_vsrln_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrln_w_d (_1, _2); ++} ++v16u8 ++__lsx_vssrln_bu_h (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vssrln_bu_h (_1, _2); ++} ++v8u16 ++__lsx_vssrln_hu_w (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vssrln_hu_w (_1, _2); ++} ++v4u32 ++__lsx_vssrln_wu_d (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vssrln_wu_d (_1, _2); ++} ++v16i8 ++__lsx_vsrlrn_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrlrn_b_h (_1, _2); ++} ++v8i16 ++__lsx_vsrlrn_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrlrn_h_w (_1, _2); ++} ++v4i32 ++__lsx_vsrlrn_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrlrn_w_d (_1, _2); ++} ++v16u8 ++__lsx_vssrlrn_bu_h (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vssrlrn_bu_h (_1, _2); ++} ++v8u16 ++__lsx_vssrlrn_hu_w (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vssrlrn_hu_w (_1, _2); ++} ++v4u32 ++__lsx_vssrlrn_wu_d (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vssrlrn_wu_d (_1, _2); ++} ++v16i8 ++__lsx_vfrstpi_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vfrstpi_b (_1, _2, 1); ++} ++v8i16 ++__lsx_vfrstpi_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vfrstpi_h (_1, _2, 1); ++} ++v16i8 ++__lsx_vfrstp_b (v16i8 _1, v16i8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vfrstp_b (_1, _2, _3); ++} ++v8i16 ++__lsx_vfrstp_h (v8i16 _1, v8i16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vfrstp_h (_1, _2, _3); ++} ++v2i64 ++__lsx_vshuf4i_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vshuf4i_d (_1, _2, 1); ++} ++v16i8 ++__lsx_vbsrl_v (v16i8 _1) ++{ ++ return __builtin_lsx_vbsrl_v (_1, 1); ++} ++v16i8 ++__lsx_vbsll_v (v16i8 _1) ++{ ++ return __builtin_lsx_vbsll_v (_1, 1); ++} ++v16i8 ++__lsx_vextrins_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vextrins_b (_1, _2, 1); ++} ++v8i16 ++__lsx_vextrins_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vextrins_h (_1, _2, 1); ++} ++v4i32 ++__lsx_vextrins_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vextrins_w (_1, _2, 1); ++} ++v2i64 ++__lsx_vextrins_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vextrins_d (_1, _2, 1); ++} ++v16i8 ++__lsx_vmskltz_b (v16i8 _1) ++{ ++ return __builtin_lsx_vmskltz_b (_1); ++} ++v8i16 ++__lsx_vmskltz_h (v8i16 _1) ++{ ++ return __builtin_lsx_vmskltz_h (_1); ++} ++v4i32 ++__lsx_vmskltz_w (v4i32 _1) ++{ ++ return __builtin_lsx_vmskltz_w (_1); ++} ++v2i64 ++__lsx_vmskltz_d (v2i64 _1) ++{ ++ return __builtin_lsx_vmskltz_d (_1); ++} ++v16i8 ++__lsx_vsigncov_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsigncov_b (_1, _2); ++} ++v8i16 ++__lsx_vsigncov_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsigncov_h (_1, _2); ++} ++v4i32 ++__lsx_vsigncov_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsigncov_w (_1, _2); ++} ++v2i64 ++__lsx_vsigncov_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsigncov_d (_1, _2); ++} ++v4f32 ++__lsx_vfmadd_s (v4f32 _1, v4f32 _2, v4f32 _3) ++{ ++ return __builtin_lsx_vfmadd_s (_1, _2, _3); ++} ++v2f64 ++__lsx_vfmadd_d (v2f64 _1, v2f64 _2, v2f64 _3) ++{ ++ return __builtin_lsx_vfmadd_d (_1, _2, _3); ++} ++v4f32 ++__lsx_vfmsub_s (v4f32 _1, v4f32 _2, v4f32 _3) ++{ ++ return __builtin_lsx_vfmsub_s (_1, _2, _3); ++} ++v2f64 ++__lsx_vfmsub_d (v2f64 _1, v2f64 _2, v2f64 _3) ++{ ++ return __builtin_lsx_vfmsub_d (_1, _2, _3); ++} ++v4f32 ++__lsx_vfnmadd_s (v4f32 _1, v4f32 _2, v4f32 _3) ++{ ++ return __builtin_lsx_vfnmadd_s (_1, _2, _3); ++} ++v2f64 ++__lsx_vfnmadd_d (v2f64 _1, v2f64 _2, v2f64 _3) ++{ ++ return __builtin_lsx_vfnmadd_d (_1, _2, _3); ++} ++v4f32 ++__lsx_vfnmsub_s (v4f32 _1, v4f32 _2, v4f32 _3) ++{ ++ return __builtin_lsx_vfnmsub_s (_1, _2, _3); ++} ++v2f64 ++__lsx_vfnmsub_d (v2f64 _1, v2f64 _2, v2f64 _3) ++{ ++ return __builtin_lsx_vfnmsub_d (_1, _2, _3); ++} ++v4i32 ++__lsx_vftintrne_w_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrne_w_s (_1); ++} ++v2i64 ++__lsx_vftintrne_l_d (v2f64 _1) ++{ ++ return __builtin_lsx_vftintrne_l_d (_1); ++} ++v4i32 ++__lsx_vftintrp_w_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrp_w_s (_1); ++} ++v2i64 ++__lsx_vftintrp_l_d (v2f64 _1) ++{ ++ return __builtin_lsx_vftintrp_l_d (_1); ++} ++v4i32 ++__lsx_vftintrm_w_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrm_w_s (_1); ++} ++v2i64 ++__lsx_vftintrm_l_d (v2f64 _1) ++{ ++ return __builtin_lsx_vftintrm_l_d (_1); ++} ++v4i32 ++__lsx_vftint_w_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vftint_w_d (_1, _2); ++} ++v4f32 ++__lsx_vffint_s_l (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vffint_s_l (_1, _2); ++} ++v4i32 ++__lsx_vftintrz_w_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vftintrz_w_d (_1, _2); ++} ++v4i32 ++__lsx_vftintrp_w_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vftintrp_w_d (_1, _2); ++} ++v4i32 ++__lsx_vftintrm_w_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vftintrm_w_d (_1, _2); ++} ++v4i32 ++__lsx_vftintrne_w_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vftintrne_w_d (_1, _2); ++} ++v2i64 ++__lsx_vftintl_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintl_l_s (_1); ++} ++v2i64 ++__lsx_vftinth_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftinth_l_s (_1); ++} ++v2f64 ++__lsx_vffinth_d_w (v4i32 _1) ++{ ++ return __builtin_lsx_vffinth_d_w (_1); ++} ++v2f64 ++__lsx_vffintl_d_w (v4i32 _1) ++{ ++ return __builtin_lsx_vffintl_d_w (_1); ++} ++v2i64 ++__lsx_vftintrzl_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrzl_l_s (_1); ++} ++v2i64 ++__lsx_vftintrzh_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrzh_l_s (_1); ++} ++v2i64 ++__lsx_vftintrpl_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrpl_l_s (_1); ++} ++v2i64 ++__lsx_vftintrph_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrph_l_s (_1); ++} ++v2i64 ++__lsx_vftintrml_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrml_l_s (_1); ++} ++v2i64 ++__lsx_vftintrmh_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrmh_l_s (_1); ++} ++v2i64 ++__lsx_vftintrnel_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrnel_l_s (_1); ++} ++v2i64 ++__lsx_vftintrneh_l_s (v4f32 _1) ++{ ++ return __builtin_lsx_vftintrneh_l_s (_1); ++} ++v4f32 ++__lsx_vfrintrne_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfrintrne_s (_1); ++} ++v2f64 ++__lsx_vfrintrne_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfrintrne_d (_1); ++} ++v4f32 ++__lsx_vfrintrz_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfrintrz_s (_1); ++} ++v2f64 ++__lsx_vfrintrz_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfrintrz_d (_1); ++} ++v4f32 ++__lsx_vfrintrp_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfrintrp_s (_1); ++} ++v2f64 ++__lsx_vfrintrp_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfrintrp_d (_1); ++} ++v4f32 ++__lsx_vfrintrm_s (v4f32 _1) ++{ ++ return __builtin_lsx_vfrintrm_s (_1); ++} ++v2f64 ++__lsx_vfrintrm_d (v2f64 _1) ++{ ++ return __builtin_lsx_vfrintrm_d (_1); ++} ++void ++__lsx_vstelm_b (v16i8 _1, void *_2) ++{ ++ return __builtin_lsx_vstelm_b (_1, _2, 1, 1); ++} ++void ++__lsx_vstelm_h (v8i16 _1, void *_2) ++{ ++ return __builtin_lsx_vstelm_h (_1, _2, 2, 1); ++} ++void ++__lsx_vstelm_w (v4i32 _1, void *_2) ++{ ++ return __builtin_lsx_vstelm_w (_1, _2, 4, 1); ++} ++void ++__lsx_vstelm_d (v2i64 _1, void *_2) ++{ ++ return __builtin_lsx_vstelm_d (_1, _2, 8, 1); ++} ++v2i64 ++__lsx_vaddwev_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vaddwev_d_w (_1, _2); ++} ++v4i32 ++__lsx_vaddwev_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vaddwev_w_h (_1, _2); ++} ++v8i16 ++__lsx_vaddwev_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vaddwev_h_b (_1, _2); ++} ++v2i64 ++__lsx_vaddwod_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vaddwod_d_w (_1, _2); ++} ++v4i32 ++__lsx_vaddwod_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vaddwod_w_h (_1, _2); ++} ++v8i16 ++__lsx_vaddwod_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vaddwod_h_b (_1, _2); ++} ++v2i64 ++__lsx_vaddwev_d_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vaddwev_d_wu (_1, _2); ++} ++v4i32 ++__lsx_vaddwev_w_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vaddwev_w_hu (_1, _2); ++} ++v8i16 ++__lsx_vaddwev_h_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vaddwev_h_bu (_1, _2); ++} ++v2i64 ++__lsx_vaddwod_d_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vaddwod_d_wu (_1, _2); ++} ++v4i32 ++__lsx_vaddwod_w_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vaddwod_w_hu (_1, _2); ++} ++v8i16 ++__lsx_vaddwod_h_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vaddwod_h_bu (_1, _2); ++} ++v2i64 ++__lsx_vaddwev_d_wu_w (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vaddwev_d_wu_w (_1, _2); ++} ++v4i32 ++__lsx_vaddwev_w_hu_h (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vaddwev_w_hu_h (_1, _2); ++} ++v8i16 ++__lsx_vaddwev_h_bu_b (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vaddwev_h_bu_b (_1, _2); ++} ++v2i64 ++__lsx_vaddwod_d_wu_w (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vaddwod_d_wu_w (_1, _2); ++} ++v4i32 ++__lsx_vaddwod_w_hu_h (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vaddwod_w_hu_h (_1, _2); ++} ++v8i16 ++__lsx_vaddwod_h_bu_b (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vaddwod_h_bu_b (_1, _2); ++} ++v2i64 ++__lsx_vsubwev_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsubwev_d_w (_1, _2); ++} ++v4i32 ++__lsx_vsubwev_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsubwev_w_h (_1, _2); ++} ++v8i16 ++__lsx_vsubwev_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsubwev_h_b (_1, _2); ++} ++v2i64 ++__lsx_vsubwod_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsubwod_d_w (_1, _2); ++} ++v4i32 ++__lsx_vsubwod_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsubwod_w_h (_1, _2); ++} ++v8i16 ++__lsx_vsubwod_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsubwod_h_b (_1, _2); ++} ++v2i64 ++__lsx_vsubwev_d_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vsubwev_d_wu (_1, _2); ++} ++v4i32 ++__lsx_vsubwev_w_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vsubwev_w_hu (_1, _2); ++} ++v8i16 ++__lsx_vsubwev_h_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vsubwev_h_bu (_1, _2); ++} ++v2i64 ++__lsx_vsubwod_d_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vsubwod_d_wu (_1, _2); ++} ++v4i32 ++__lsx_vsubwod_w_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vsubwod_w_hu (_1, _2); ++} ++v8i16 ++__lsx_vsubwod_h_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vsubwod_h_bu (_1, _2); ++} ++v2i64 ++__lsx_vaddwev_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vaddwev_q_d (_1, _2); ++} ++v2i64 ++__lsx_vaddwod_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vaddwod_q_d (_1, _2); ++} ++v2i64 ++__lsx_vaddwev_q_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vaddwev_q_du (_1, _2); ++} ++v2i64 ++__lsx_vaddwod_q_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vaddwod_q_du (_1, _2); ++} ++v2i64 ++__lsx_vsubwev_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsubwev_q_d (_1, _2); ++} ++v2i64 ++__lsx_vsubwod_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsubwod_q_d (_1, _2); ++} ++v2i64 ++__lsx_vsubwev_q_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vsubwev_q_du (_1, _2); ++} ++v2i64 ++__lsx_vsubwod_q_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vsubwod_q_du (_1, _2); ++} ++v2i64 ++__lsx_vaddwev_q_du_d (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vaddwev_q_du_d (_1, _2); ++} ++v2i64 ++__lsx_vaddwod_q_du_d (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vaddwod_q_du_d (_1, _2); ++} ++v2i64 ++__lsx_vmulwev_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmulwev_d_w (_1, _2); ++} ++v4i32 ++__lsx_vmulwev_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmulwev_w_h (_1, _2); ++} ++v8i16 ++__lsx_vmulwev_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmulwev_h_b (_1, _2); ++} ++v2i64 ++__lsx_vmulwod_d_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmulwod_d_w (_1, _2); ++} ++v4i32 ++__lsx_vmulwod_w_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmulwod_w_h (_1, _2); ++} ++v8i16 ++__lsx_vmulwod_h_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmulwod_h_b (_1, _2); ++} ++v2i64 ++__lsx_vmulwev_d_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vmulwev_d_wu (_1, _2); ++} ++v4i32 ++__lsx_vmulwev_w_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vmulwev_w_hu (_1, _2); ++} ++v8i16 ++__lsx_vmulwev_h_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vmulwev_h_bu (_1, _2); ++} ++v2i64 ++__lsx_vmulwod_d_wu (v4u32 _1, v4u32 _2) ++{ ++ return __builtin_lsx_vmulwod_d_wu (_1, _2); ++} ++v4i32 ++__lsx_vmulwod_w_hu (v8u16 _1, v8u16 _2) ++{ ++ return __builtin_lsx_vmulwod_w_hu (_1, _2); ++} ++v8i16 ++__lsx_vmulwod_h_bu (v16u8 _1, v16u8 _2) ++{ ++ return __builtin_lsx_vmulwod_h_bu (_1, _2); ++} ++v2i64 ++__lsx_vmulwev_d_wu_w (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmulwev_d_wu_w (_1, _2); ++} ++v4i32 ++__lsx_vmulwev_w_hu_h (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmulwev_w_hu_h (_1, _2); ++} ++v8i16 ++__lsx_vmulwev_h_bu_b (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmulwev_h_bu_b (_1, _2); ++} ++v2i64 ++__lsx_vmulwod_d_wu_w (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vmulwod_d_wu_w (_1, _2); ++} ++v4i32 ++__lsx_vmulwod_w_hu_h (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vmulwod_w_hu_h (_1, _2); ++} ++v8i16 ++__lsx_vmulwod_h_bu_b (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vmulwod_h_bu_b (_1, _2); ++} ++v2i64 ++__lsx_vmulwev_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmulwev_q_d (_1, _2); ++} ++v2i64 ++__lsx_vmulwod_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmulwod_q_d (_1, _2); ++} ++v2i64 ++__lsx_vmulwev_q_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vmulwev_q_du (_1, _2); ++} ++v2i64 ++__lsx_vmulwod_q_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vmulwod_q_du (_1, _2); ++} ++v2i64 ++__lsx_vmulwev_q_du_d (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmulwev_q_du_d (_1, _2); ++} ++v2i64 ++__lsx_vmulwod_q_du_d (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vmulwod_q_du_d (_1, _2); ++} ++v2i64 ++__lsx_vhaddw_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vhaddw_q_d (_1, _2); ++} ++v2u64 ++__lsx_vhaddw_qu_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vhaddw_qu_du (_1, _2); ++} ++v2i64 ++__lsx_vhsubw_q_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vhsubw_q_d (_1, _2); ++} ++v2u64 ++__lsx_vhsubw_qu_du (v2u64 _1, v2u64 _2) ++{ ++ return __builtin_lsx_vhsubw_qu_du (_1, _2); ++} ++v2i64 ++__lsx_vmaddwev_d_w (v2i64 _1, v4i32 _2, v4i32 _3) ++{ ++ return __builtin_lsx_vmaddwev_d_w (_1, _2, _3); ++} ++v4i32 ++__lsx_vmaddwev_w_h (v4i32 _1, v8i16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vmaddwev_w_h (_1, _2, _3); ++} ++v8i16 ++__lsx_vmaddwev_h_b (v8i16 _1, v16i8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vmaddwev_h_b (_1, _2, _3); ++} ++v2u64 ++__lsx_vmaddwev_d_wu (v2u64 _1, v4u32 _2, v4u32 _3) ++{ ++ return __builtin_lsx_vmaddwev_d_wu (_1, _2, _3); ++} ++v4u32 ++__lsx_vmaddwev_w_hu (v4u32 _1, v8u16 _2, v8u16 _3) ++{ ++ return __builtin_lsx_vmaddwev_w_hu (_1, _2, _3); ++} ++v8u16 ++__lsx_vmaddwev_h_bu (v8u16 _1, v16u8 _2, v16u8 _3) ++{ ++ return __builtin_lsx_vmaddwev_h_bu (_1, _2, _3); ++} ++v2i64 ++__lsx_vmaddwod_d_w (v2i64 _1, v4i32 _2, v4i32 _3) ++{ ++ return __builtin_lsx_vmaddwod_d_w (_1, _2, _3); ++} ++v4i32 ++__lsx_vmaddwod_w_h (v4i32 _1, v8i16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vmaddwod_w_h (_1, _2, _3); ++} ++v8i16 ++__lsx_vmaddwod_h_b (v8i16 _1, v16i8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vmaddwod_h_b (_1, _2, _3); ++} ++v2u64 ++__lsx_vmaddwod_d_wu (v2u64 _1, v4u32 _2, v4u32 _3) ++{ ++ return __builtin_lsx_vmaddwod_d_wu (_1, _2, _3); ++} ++v4u32 ++__lsx_vmaddwod_w_hu (v4u32 _1, v8u16 _2, v8u16 _3) ++{ ++ return __builtin_lsx_vmaddwod_w_hu (_1, _2, _3); ++} ++v8u16 ++__lsx_vmaddwod_h_bu (v8u16 _1, v16u8 _2, v16u8 _3) ++{ ++ return __builtin_lsx_vmaddwod_h_bu (_1, _2, _3); ++} ++v2i64 ++__lsx_vmaddwev_d_wu_w (v2i64 _1, v4u32 _2, v4i32 _3) ++{ ++ return __builtin_lsx_vmaddwev_d_wu_w (_1, _2, _3); ++} ++v4i32 ++__lsx_vmaddwev_w_hu_h (v4i32 _1, v8u16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vmaddwev_w_hu_h (_1, _2, _3); ++} ++v8i16 ++__lsx_vmaddwev_h_bu_b (v8i16 _1, v16u8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vmaddwev_h_bu_b (_1, _2, _3); ++} ++v2i64 ++__lsx_vmaddwod_d_wu_w (v2i64 _1, v4u32 _2, v4i32 _3) ++{ ++ return __builtin_lsx_vmaddwod_d_wu_w (_1, _2, _3); ++} ++v4i32 ++__lsx_vmaddwod_w_hu_h (v4i32 _1, v8u16 _2, v8i16 _3) ++{ ++ return __builtin_lsx_vmaddwod_w_hu_h (_1, _2, _3); ++} ++v8i16 ++__lsx_vmaddwod_h_bu_b (v8i16 _1, v16u8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vmaddwod_h_bu_b (_1, _2, _3); ++} ++v2i64 ++__lsx_vmaddwev_q_d (v2i64 _1, v2i64 _2, v2i64 _3) ++{ ++ return __builtin_lsx_vmaddwev_q_d (_1, _2, _3); ++} ++v2i64 ++__lsx_vmaddwod_q_d (v2i64 _1, v2i64 _2, v2i64 _3) ++{ ++ return __builtin_lsx_vmaddwod_q_d (_1, _2, _3); ++} ++v2u64 ++__lsx_vmaddwev_q_du (v2u64 _1, v2u64 _2, v2u64 _3) ++{ ++ return __builtin_lsx_vmaddwev_q_du (_1, _2, _3); ++} ++v2u64 ++__lsx_vmaddwod_q_du (v2u64 _1, v2u64 _2, v2u64 _3) ++{ ++ return __builtin_lsx_vmaddwod_q_du (_1, _2, _3); ++} ++v2i64 ++__lsx_vmaddwev_q_du_d (v2i64 _1, v2u64 _2, v2i64 _3) ++{ ++ return __builtin_lsx_vmaddwev_q_du_d (_1, _2, _3); ++} ++v2i64 ++__lsx_vmaddwod_q_du_d (v2i64 _1, v2u64 _2, v2i64 _3) ++{ ++ return __builtin_lsx_vmaddwod_q_du_d (_1, _2, _3); ++} ++v16i8 ++__lsx_vrotr_b (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vrotr_b (_1, _2); ++} ++v8i16 ++__lsx_vrotr_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vrotr_h (_1, _2); ++} ++v4i32 ++__lsx_vrotr_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vrotr_w (_1, _2); ++} ++v2i64 ++__lsx_vrotr_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vrotr_d (_1, _2); ++} ++v2i64 ++__lsx_vadd_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vadd_q (_1, _2); ++} ++v2i64 ++__lsx_vsub_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsub_q (_1, _2); ++} ++v16i8 ++__lsx_vldrepl_b (void *_1) ++{ ++ return __builtin_lsx_vldrepl_b (_1, 1); ++} ++v8i16 ++__lsx_vldrepl_h (void *_1) ++{ ++ return __builtin_lsx_vldrepl_h (_1, 2); ++} ++v4i32 ++__lsx_vldrepl_w (void *_1) ++{ ++ return __builtin_lsx_vldrepl_w (_1, 4); ++} ++v2i64 ++__lsx_vldrepl_d (void *_1) ++{ ++ return __builtin_lsx_vldrepl_d (_1, 8); ++} ++v16i8 ++__lsx_vmskgez_b (v16i8 _1) ++{ ++ return __builtin_lsx_vmskgez_b (_1); ++} ++v16i8 ++__lsx_vmsknz_b (v16i8 _1) ++{ ++ return __builtin_lsx_vmsknz_b (_1); ++} ++v8i16 ++__lsx_vexth_h_b (v16i8 _1) ++{ ++ return __builtin_lsx_vexth_h_b (_1); ++} ++v4i32 ++__lsx_vexth_w_h (v8i16 _1) ++{ ++ return __builtin_lsx_vexth_w_h (_1); ++} ++v2i64 ++__lsx_vexth_d_w (v4i32 _1) ++{ ++ return __builtin_lsx_vexth_d_w (_1); ++} ++v2i64 ++__lsx_vexth_q_d (v2i64 _1) ++{ ++ return __builtin_lsx_vexth_q_d (_1); ++} ++v8u16 ++__lsx_vexth_hu_bu (v16u8 _1) ++{ ++ return __builtin_lsx_vexth_hu_bu (_1); ++} ++v4u32 ++__lsx_vexth_wu_hu (v8u16 _1) ++{ ++ return __builtin_lsx_vexth_wu_hu (_1); ++} ++v2u64 ++__lsx_vexth_du_wu (v4u32 _1) ++{ ++ return __builtin_lsx_vexth_du_wu (_1); ++} ++v2u64 ++__lsx_vexth_qu_du (v2u64 _1) ++{ ++ return __builtin_lsx_vexth_qu_du (_1); ++} ++v16i8 ++__lsx_vrotri_b (v16i8 _1) ++{ ++ return __builtin_lsx_vrotri_b (_1, 1); ++} ++v8i16 ++__lsx_vrotri_h (v8i16 _1) ++{ ++ return __builtin_lsx_vrotri_h (_1, 1); ++} ++v4i32 ++__lsx_vrotri_w (v4i32 _1) ++{ ++ return __builtin_lsx_vrotri_w (_1, 1); ++} ++v2i64 ++__lsx_vrotri_d (v2i64 _1) ++{ ++ return __builtin_lsx_vrotri_d (_1, 1); ++} ++v2i64 ++__lsx_vextl_q_d (v2i64 _1) ++{ ++ return __builtin_lsx_vextl_q_d (_1); ++} ++v16i8 ++__lsx_vsrlni_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsrlni_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vsrlni_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrlni_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vsrlni_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrlni_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vsrlni_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrlni_d_q (_1, _2, 1); ++} ++v16i8 ++__lsx_vsrlrni_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsrlrni_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vsrlrni_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrlrni_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vsrlrni_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrlrni_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vsrlrni_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrlrni_d_q (_1, _2, 1); ++} ++v16i8 ++__lsx_vssrlni_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrlni_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vssrlni_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrlni_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vssrlni_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrlni_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vssrlni_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrlni_d_q (_1, _2, 1); ++} ++v16u8 ++__lsx_vssrlni_bu_h (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrlni_bu_h (_1, _2, 1); ++} ++v8u16 ++__lsx_vssrlni_hu_w (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrlni_hu_w (_1, _2, 1); ++} ++v4u32 ++__lsx_vssrlni_wu_d (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrlni_wu_d (_1, _2, 1); ++} ++v2u64 ++__lsx_vssrlni_du_q (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrlni_du_q (_1, _2, 1); ++} ++v16i8 ++__lsx_vssrlrni_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrlrni_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vssrlrni_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrlrni_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vssrlrni_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrlrni_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vssrlrni_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrlrni_d_q (_1, _2, 1); ++} ++v16u8 ++__lsx_vssrlrni_bu_h (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrlrni_bu_h (_1, _2, 1); ++} ++v8u16 ++__lsx_vssrlrni_hu_w (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrlrni_hu_w (_1, _2, 1); ++} ++v4u32 ++__lsx_vssrlrni_wu_d (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrlrni_wu_d (_1, _2, 1); ++} ++v2u64 ++__lsx_vssrlrni_du_q (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrlrni_du_q (_1, _2, 1); ++} ++v16i8 ++__lsx_vsrani_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsrani_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vsrani_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrani_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vsrani_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrani_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vsrani_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrani_d_q (_1, _2, 1); ++} ++v16i8 ++__lsx_vsrarni_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vsrarni_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vsrarni_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vsrarni_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vsrarni_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vsrarni_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vsrarni_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vsrarni_d_q (_1, _2, 1); ++} ++v16i8 ++__lsx_vssrani_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrani_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vssrani_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrani_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vssrani_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrani_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vssrani_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrani_d_q (_1, _2, 1); ++} ++v16u8 ++__lsx_vssrani_bu_h (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrani_bu_h (_1, _2, 1); ++} ++v8u16 ++__lsx_vssrani_hu_w (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrani_hu_w (_1, _2, 1); ++} ++v4u32 ++__lsx_vssrani_wu_d (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrani_wu_d (_1, _2, 1); ++} ++v2u64 ++__lsx_vssrani_du_q (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrani_du_q (_1, _2, 1); ++} ++v16i8 ++__lsx_vssrarni_b_h (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrarni_b_h (_1, _2, 1); ++} ++v8i16 ++__lsx_vssrarni_h_w (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrarni_h_w (_1, _2, 1); ++} ++v4i32 ++__lsx_vssrarni_w_d (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrarni_w_d (_1, _2, 1); ++} ++v2i64 ++__lsx_vssrarni_d_q (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrarni_d_q (_1, _2, 1); ++} ++v16u8 ++__lsx_vssrarni_bu_h (v16u8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vssrarni_bu_h (_1, _2, 1); ++} ++v8u16 ++__lsx_vssrarni_hu_w (v8u16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrarni_hu_w (_1, _2, 1); ++} ++v4u32 ++__lsx_vssrarni_wu_d (v4u32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrarni_wu_d (_1, _2, 1); ++} ++v2u64 ++__lsx_vssrarni_du_q (v2u64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrarni_du_q (_1, _2, 1); ++} ++v4i32 ++__lsx_vpermi_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vpermi_w (_1, _2, 1); ++} ++v16i8 ++__lsx_vld (void *_1) ++{ ++ return __builtin_lsx_vld (_1, 1); ++} ++void ++__lsx_vst (v16i8 _1, void *_2) ++{ ++ return __builtin_lsx_vst (_1, _2, 1); ++} ++v16i8 ++__lsx_vssrlrn_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrlrn_b_h (_1, _2); ++} ++v8i16 ++__lsx_vssrlrn_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrlrn_h_w (_1, _2); ++} ++v4i32 ++__lsx_vssrlrn_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrlrn_w_d (_1, _2); ++} ++v16i8 ++__lsx_vssrln_b_h (v8i16 _1, v8i16 _2) ++{ ++ return __builtin_lsx_vssrln_b_h (_1, _2); ++} ++v8i16 ++__lsx_vssrln_h_w (v4i32 _1, v4i32 _2) ++{ ++ return __builtin_lsx_vssrln_h_w (_1, _2); ++} ++v4i32 ++__lsx_vssrln_w_d (v2i64 _1, v2i64 _2) ++{ ++ return __builtin_lsx_vssrln_w_d (_1, _2); ++} ++v16i8 ++__lsx_vorn_v (v16i8 _1, v16i8 _2) ++{ ++ return __builtin_lsx_vorn_v (_1, _2); ++} ++v2i64 ++__lsx_vldi () ++{ ++ return __builtin_lsx_vldi (1); ++} ++v16i8 ++__lsx_vshuf_b (v16i8 _1, v16i8 _2, v16i8 _3) ++{ ++ return __builtin_lsx_vshuf_b (_1, _2, _3); ++} ++v16i8 ++__lsx_vldx (void *_1) ++{ ++ return __builtin_lsx_vldx (_1, 1); ++} ++void ++__lsx_vstx (v16i8 _1, void *_2) ++{ ++ return __builtin_lsx_vstx (_1, _2, 1); ++} ++v2u64 ++__lsx_vextl_qu_du (v2u64 _1) ++{ ++ return __builtin_lsx_vextl_qu_du (_1); ++} ++int ++__lsx_bnz_b (v16u8 _1) ++{ ++ return __builtin_lsx_bnz_b (_1); ++} ++int ++__lsx_bnz_d (v2u64 _1) ++{ ++ return __builtin_lsx_bnz_d (_1); ++} ++int ++__lsx_bnz_h (v8u16 _1) ++{ ++ return __builtin_lsx_bnz_h (_1); ++} ++int ++__lsx_bnz_v (v16u8 _1) ++{ ++ return __builtin_lsx_bnz_v (_1); ++} ++int ++__lsx_bnz_w (v4u32 _1) ++{ ++ return __builtin_lsx_bnz_w (_1); ++} ++int ++__lsx_bz_b (v16u8 _1) ++{ ++ return __builtin_lsx_bz_b (_1); ++} ++int ++__lsx_bz_d (v2u64 _1) ++{ ++ return __builtin_lsx_bz_d (_1); ++} ++int ++__lsx_bz_h (v8u16 _1) ++{ ++ return __builtin_lsx_bz_h (_1); ++} ++int ++__lsx_bz_v (v16u8 _1) ++{ ++ return __builtin_lsx_bz_v (_1); ++} ++int ++__lsx_bz_w (v4u32 _1) ++{ ++ return __builtin_lsx_bz_w (_1); ++} ++v2i64 ++__lsx_vfcmp_caf_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_caf_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_caf_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_caf_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_ceq_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_ceq_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_ceq_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_ceq_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cle_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cle_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cle_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cle_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_clt_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_clt_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_clt_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_clt_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cne_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cne_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cne_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cne_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cor_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cor_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cor_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cor_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cueq_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cueq_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cueq_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cueq_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cule_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cule_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cule_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cule_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cult_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cult_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cult_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cult_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cun_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cun_d (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_cune_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_cune_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cune_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cune_s (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_cun_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_cun_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_saf_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_saf_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_saf_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_saf_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_seq_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_seq_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_seq_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_seq_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sle_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sle_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sle_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sle_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_slt_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_slt_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_slt_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_slt_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sne_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sne_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sne_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sne_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sor_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sor_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sor_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sor_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sueq_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sueq_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sueq_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sueq_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sule_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sule_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sule_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sule_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sult_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sult_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sult_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sult_s (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sun_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sun_d (_1, _2); ++} ++v2i64 ++__lsx_vfcmp_sune_d (v2f64 _1, v2f64 _2) ++{ ++ return __builtin_lsx_vfcmp_sune_d (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sune_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sune_s (_1, _2); ++} ++v4i32 ++__lsx_vfcmp_sun_s (v4f32 _1, v4f32 _2) ++{ ++ return __builtin_lsx_vfcmp_sun_s (_1, _2); ++} ++v16i8 ++__lsx_vrepli_b () ++{ ++ return __builtin_lsx_vrepli_b (1); ++} ++v2i64 ++__lsx_vrepli_d () ++{ ++ return __builtin_lsx_vrepli_d (1); ++} ++v8i16 ++__lsx_vrepli_h () ++{ ++ return __builtin_lsx_vrepli_h (1); ++} ++v4i32 ++__lsx_vrepli_w () ++{ ++ return __builtin_lsx_vrepli_w (1); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-addition-instructi.patch
Added
@@ -0,0 +1,7181 @@ +From 2cb3122527add8fee54dca91824d82a02d5602e3 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 09:58:48 +0800 +Subject: PATCH 080/124 LoongArch: Add tests for SX vector addition + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vadd.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vadda.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vaddi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vaddwev-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vaddwev-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vaddwev-3.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vaddwod-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vaddwod-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vaddwod-3.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vhaddw-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vhaddw-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmadd.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaddwev-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaddwev-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaddwev-3.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaddwod-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaddwod-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaddwod-3.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vadd.c | 416 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vadda.c | 344 ++++++++++++ + .../loongarch/vector/lsx/lsx-vaddi.c | 251 +++++++++ + .../loongarch/vector/lsx/lsx-vaddwev-1.c | 335 ++++++++++++ + .../loongarch/vector/lsx/lsx-vaddwev-2.c | 344 ++++++++++++ + .../loongarch/vector/lsx/lsx-vaddwev-3.c | 425 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vaddwod-1.c | 408 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vaddwod-2.c | 344 ++++++++++++ + .../loongarch/vector/lsx/lsx-vaddwod-3.c | 237 +++++++++ + .../loongarch/vector/lsx/lsx-vhaddw-1.c | 488 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vhaddw-2.c | 452 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vmadd.c | 450 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vmaddwev-1.c | 472 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vmaddwev-2.c | 383 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vmaddwev-3.c | 383 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vmaddwod-1.c | 372 +++++++++++++ + .../loongarch/vector/lsx/lsx-vmaddwod-2.c | 438 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vmaddwod-3.c | 460 +++++++++++++++++ + 18 files changed, 7002 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadd.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadda.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmadd.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-3.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadd.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadd.c +new file mode 100644 +index 000000000..7cfb989e4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadd.c +@@ -0,0 +1,416 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_op00) = 0x000201000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000fc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_result0) = 0x0002010000fc000b; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000017fda829; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000001fffe; ++ *((unsigned long *)&__m128i_op11) = 0x7f7f7f7f00107f04; ++ *((unsigned long *)&__m128i_op10) = 0x7f0000fd7f0000fd; ++ *((unsigned long *)&__m128i_result1) = 0x7e7e7e7eff0f7f04; ++ *((unsigned long *)&__m128i_result0) = 0x7f0000fd7f01fffb; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf4b6f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_op11) = 0x195f307a5d04acbb; ++ *((unsigned long *)&__m128i_op10) = 0x6a1a3fbb3c90260e; ++ *((unsigned long *)&__m128i_result1) = 0x19df307a5d04acbb; ++ *((unsigned long *)&__m128i_result0) = 0x5ed032b06bde1ab6; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5555001400005111; ++ *((unsigned long *)&__m128i_op00) = 0xffabbeab55110140; ++ *((unsigned long *)&__m128i_op11) = 0x5555001400005111; ++ *((unsigned long *)&__m128i_op10) = 0xffabbeab55110140; ++ *((unsigned long *)&__m128i_result1) = 0xaaaa00280000a222; ++ *((unsigned long *)&__m128i_result0) = 0xfe567c56aa220280; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf51cf8dad6040188; ++ *((unsigned long *)&__m128i_op10) = 0x0982e2daf234ed87; ++ *((unsigned long *)&__m128i_result1) = 0xf51cf8dad6040188; ++ *((unsigned long *)&__m128i_result0) = 0x0982e2daf234ed87; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000490000004d; ++ *((unsigned long *)&__m128i_op00) = 0x00000001ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000073; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000002a; ++ *((unsigned long *)&__m128i_result1) = 0x00000049000000c0; ++ *((unsigned long *)&__m128i_result0) = 0x00000001ffffff29; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000bd3d; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fff0000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000bd30; ++ *((unsigned long *)&__m128i_op10) = 0x0000000d7fff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000007a6d; ++ *((unsigned long *)&__m128i_result0) = 0x0000000dfefe0000; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfefa000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_result0) = 0xfefefefefefefefe; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0038000000051fff; ++ *((unsigned long *)&__m128i_op00) = 0x003c000000022021; ++ *((unsigned long *)&__m128i_op11) = 0x7fff0101ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffffa0204000; ++ *((unsigned long *)&__m128i_result1) = 0x7f370101ff04ffff; ++ *((unsigned long *)&__m128i_result0) = 0x7f3bffffa0226021; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1baf8eabd26bc629; ++ *((unsigned long *)&__m128i_op00) = 0x1c2640b9a8e9fb49; ++ *((unsigned long *)&__m128i_op11) = 0x0002dab8746acf8e; ++ *((unsigned long *)&__m128i_op10) = 0x00036dd1c5c15856; ++ *((unsigned long *)&__m128i_result1) = 0x1bb1686346d595b7; ++ *((unsigned long *)&__m128i_result0) = 0x1c29ad8a6daa539f; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op11) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfeffffffffff0002; ++ __m128i_out = __lsx_vadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001ffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xff800000c3080000; ++ *((unsigned long *)&__m128i_result1) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result0) = 0xff81ffffc3080000; ++ __m128i_out = __lsx_vadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_op00) = 0x004200a000200001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_result0) = 0x004200a000200001; ++ __m128i_out = __lsx_vadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_op10) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_result1) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_result0) = 0x0000001f0000001f; ++ __m128i_out = __lsx_vadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0029aeaca57d74e6; ++ *((unsigned long *)&__m128i_op00) = 0xdbe332365392c686; ++ *((unsigned long *)&__m128i_op11) = 0x000056f64adb9464; ++ *((unsigned long *)&__m128i_op10) = 0x29ca096f235819c2; ++ *((unsigned long *)&__m128i_result1) = 0x002a05a2f059094a; ++ *((unsigned long *)&__m128i_result0) = 0x05ad3ba576eae048; ++ __m128i_out = __lsx_vadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000040d; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op00) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_result0) = 0x0000001300000013; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_result0) = 0x00000001000000ff; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000300000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result1) = 0x00000002fffffffb; ++ *((unsigned long *)&__m128i_result0) = 0x000000010000fffb; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000060000000e; ++ *((unsigned long *)&__m128i_op00) = 0x0000001201fe01e9; ++ *((unsigned long *)&__m128i_op11) = 0x000000060000000e; ++ *((unsigned long *)&__m128i_op10) = 0x0000001201fe01e9; ++ *((unsigned long *)&__m128i_result1) = 0x0000000c0000001c; ++ *((unsigned long *)&__m128i_result0) = 0x0000002403fc03d2; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfff1000100010001; ++ *((unsigned long *)&__m128i_result0) = 0xfff1000100010001; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_op10) = 0xa352bfac9269e0aa; ++ *((unsigned long *)&__m128i_result1) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_result0) = 0xa352bfac9269e0aa; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffa; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001001100110068; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001001100110067; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x379674c000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3789f68000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x379674c000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3789f68000000000; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000555889; ++ *((unsigned long *)&__m128i_op00) = 0x0000000002580f01; ++ *((unsigned long *)&__m128i_op11) = 0x00060fbf02040fbf; ++ *((unsigned long *)&__m128i_op10) = 0x00020fbf02000fbf; ++ *((unsigned long *)&__m128i_result1) = 0x00060fbf02596848; ++ *((unsigned long *)&__m128i_result0) = 0x00020fbf04581ec0; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001388928513889; ++ *((unsigned long *)&__m128i_op00) = 0x006938094a013889; ++ *((unsigned long *)&__m128i_op11) = 0x0001388928513889; ++ *((unsigned long *)&__m128i_op10) = 0x006938094a013889; ++ *((unsigned long *)&__m128i_result1) = 0x0002711250a27112; ++ *((unsigned long *)&__m128i_result0) = 0x00d2701294027112; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op00) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op11) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_op10) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_result1) = 0x202544f490f2de35; ++ *((unsigned long *)&__m128i_result0) = 0x202544f490f2de35; ++ __m128i_out = __lsx_vadd_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadda.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadda.c +new file mode 100644 +index 000000000..4bb699eab +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vadda.c +@@ -0,0 +1,344 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op10) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_result1) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_result0) = 0x52527d7d52527d7d; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffc001f; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0101010202050120; ++ *((unsigned long *)&__m128i_result0) = 0x0101010102020202; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0003000300030003; ++ *((unsigned long *)&__m128i_op00) = 0x0003000700020005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0003000300030003; ++ *((unsigned long *)&__m128i_result0) = 0x0003000700020005; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_op00) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_result0) = 0x4f8000004f800000; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_result1) = 0x0003000300030004; ++ *((unsigned long *)&__m128i_result0) = 0x0003000300030004; ++ __m128i_out = __lsx_vadda_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5c9c9c9ce3636363; ++ *((unsigned long *)&__m128i_op00) = 0x63635c9e63692363; ++ *((unsigned long *)&__m128i_op11) = 0xf0fd800080000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000a00028004000; ++ *((unsigned long *)&__m128i_result1) = 0x6b9fe3649c9d6363; ++ *((unsigned long *)&__m128i_result0) = 0x6363bc9e8b696363; ++ __m128i_out = __lsx_vadda_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_op00) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result1) = 0x1111113111111131; ++ *((unsigned long *)&__m128i_result0) = 0x1111113111111131; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000006a9a5c; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000092444; ++ *((unsigned long *)&__m128i_op11) = 0x00000000006a9a5c; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000092444; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000d4ccb8; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000124888; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x76f424887fffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfff082f000000000; ++ *((unsigned long *)&__m128i_op10) = 0x003f000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000f7d1000000001; ++ *((unsigned long *)&__m128i_result0) = 0x773324887fffffff; ++ __m128i_out = __lsx_vadda_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op00) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_op11) = 0x5a6f5c53ebed3faa; ++ *((unsigned long *)&__m128i_op10) = 0xa36aca4435b8b8e1; ++ *((unsigned long *)&__m128i_result1) = 0x5a6f61865d36d3aa; ++ *((unsigned long *)&__m128i_result0) = 0x7bea6962a0bfb621; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000008140c80; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000008140c80; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000fffe0000ff45; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff000000b9; ++ *((unsigned long *)&__m128i_op11) = 0xffd5002affffffff; ++ *((unsigned long *)&__m128i_op10) = 0x343d8dc6b0ed5a08; ++ *((unsigned long *)&__m128i_result1) = 0x012b012c01010246; ++ *((unsigned long *)&__m128i_result0) = 0x353e743b50135a4f; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op10) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_result1) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_result0) = 0x0003c853c843c87e; ++ __m128i_out = __lsx_vadda_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffe000ffdf; ++ *((unsigned long *)&__m128i_result1) = 0x0000200000002001; ++ *((unsigned long *)&__m128i_result0) = 0x000000001fff0021; ++ __m128i_out = __lsx_vadda_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010109; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000005452505; ++ *((unsigned long *)&__m128i_op00) = 0x00000004442403e4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffe0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000005452505; ++ *((unsigned long *)&__m128i_result0) = 0x000000044525043c; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xbafebb00ffd500fe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op00) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_result0) = 0x0000208000002080; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op00) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op11) = 0x003f0000003f0000; ++ *((unsigned long *)&__m128i_op10) = 0x003f0000003f0000; ++ *((unsigned long *)&__m128i_result1) = 0x803e0000803e0000; ++ *((unsigned long *)&__m128i_result0) = 0x803e0000803e0000; ++ __m128i_out = __lsx_vadda_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000008000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000008000; ++ *((unsigned long *)&__m128i_result1) = 0x0000800000008000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000008000; ++ __m128i_out = __lsx_vadda_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001400000014; ++ *((unsigned long *)&__m128i_op00) = 0x0000001400000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff9000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffc000400000000; ++ *((unsigned long *)&__m128i_result1) = 0x0007001400000014; ++ *((unsigned long *)&__m128i_result0) = 0x0004001000000000; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0xfefeff00fefeff00; ++ *((unsigned long *)&__m128i_result0) = 0xfefeff00fefeff00; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadda_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op00) = 0x0000000024170000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000020300000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_result0) = 0x0000000044470000; ++ __m128i_out = __lsx_vadda_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0xff01ff01ac025c87; ++ *((unsigned long *)&__m128i_op10) = 0xff01ff01ac465ca1; ++ *((unsigned long *)&__m128i_result1) = 0x64616462b76106dc; ++ *((unsigned long *)&__m128i_result0) = 0x64616462b71d06c2; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffaeffaeffaeffae; ++ *((unsigned long *)&__m128i_op10) = 0xffaeffaeffaeffae; ++ *((unsigned long *)&__m128i_result1) = 0x0051005200510052; ++ *((unsigned long *)&__m128i_result0) = 0x0051005200510052; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x3bc000003a800000; ++ *((unsigned long *)&__m128i_op11) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_op10) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_result1) = 0x4480000044800000; ++ *((unsigned long *)&__m128i_result0) = 0x45c0000044800000; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result0) = 0x6363636463636363; ++ __m128i_out = __lsx_vadda_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddi.c +new file mode 100644 +index 000000000..77afabe92 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddi.c +@@ -0,0 +1,251 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x1414141414141415; ++ *((unsigned long *)&__m128i_result0) = 0x1414141414141415; ++ __m128i_out = __lsx_vaddi_bu (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0505050505050505; ++ *((unsigned long *)&__m128i_result0) = 0x0505050504040404; ++ __m128i_out = __lsx_vaddi_bu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000008140c80; ++ *((unsigned long *)&__m128i_result1) = 0x1f1f1f1f1f1f1f1f; ++ *((unsigned long *)&__m128i_result0) = 0x1f1f1f1f27332b9f; ++ __m128i_out = __lsx_vaddi_bu (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_result0) = 0x0303030303030304; ++ __m128i_out = __lsx_vaddi_bu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x8f8f8f8f8f8f8f8f; ++ *((unsigned long *)&__m128i_result0) = 0x8f8f8f8f8f8f8f8f; ++ __m128i_out = __lsx_vaddi_bu (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0018001800180018; ++ *((unsigned long *)&__m128i_result0) = 0x0018001800180018; ++ __m128i_out = __lsx_vaddi_hu (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0019081900190019; ++ *((unsigned long *)&__m128i_result0) = 0x0019081900190019; ++ __m128i_out = __lsx_vaddi_hu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result0) = 0x000a000a000a000a; ++ __m128i_out = __lsx_vaddi_hu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc1000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffcc000b000b000b; ++ *((unsigned long *)&__m128i_result0) = 0x000b000b010a000b; ++ __m128i_out = __lsx_vaddi_hu (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001f001f001f001f; ++ *((unsigned long *)&__m128i_result0) = 0x001f001f001f001f; ++ __m128i_out = __lsx_vaddi_hu (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001c001c001c001c; ++ *((unsigned long *)&__m128i_result0) = 0x001c001c001c001c; ++ __m128i_out = __lsx_vaddi_hu (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0x680485c8b304b019; ++ *((unsigned long *)&__m128i_result0) = 0xc89d7f0fed582019; ++ __m128i_out = __lsx_vaddi_hu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000a0000000a; ++ *((unsigned long *)&__m128i_result0) = 0x0000000a0000000a; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op00) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128i_result1) = 0x000000090100000a; ++ *((unsigned long *)&__m128i_result0) = 0xffffe009ffff2008; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000300000003; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfc01fcfefc02fdf7; ++ *((unsigned long *)&__m128i_op00) = 0xfe00fcfffe01fd01; ++ *((unsigned long *)&__m128i_result1) = 0xfc01fd13fc02fe0c; ++ *((unsigned long *)&__m128i_result0) = 0xfe00fd14fe01fd16; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_result0) = 0x0000001300000013; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000bd3d; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000c0000bd49; ++ *((unsigned long *)&__m128i_result0) = 0x0000000c7fff000c; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffe0001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000500000005; ++ *((unsigned long *)&__m128i_result0) = 0x00000005fffe0006; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000fffffeff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000009ffffff08; ++ *((unsigned long *)&__m128i_result0) = 0x0000000900000009; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x55aa55aa55aa55ab; ++ *((unsigned long *)&__m128i_op00) = 0xaa55555655aaaaa8; ++ *((unsigned long *)&__m128i_result1) = 0x55aa55c355aa55c4; ++ *((unsigned long *)&__m128i_result0) = 0xaa55556f55aaaac1; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000e0000002e; ++ *((unsigned long *)&__m128i_result0) = 0x0000000e0000004e; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000400000004; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x003f000400000003; ++ *((unsigned long *)&__m128i_result0) = 0x003f000400000003; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff8000010f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000900000009; ++ *((unsigned long *)&__m128i_result0) = 0xff80000a0f800009; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb020302101b03; ++ *((unsigned long *)&__m128i_op00) = 0x020310d0c0030220; ++ *((unsigned long *)&__m128i_result1) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_result0) = 0x020310edc003023d; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x59f7fd7059f7fd70; ++ *((unsigned long *)&__m128i_result1) = 0x0000001700000017; ++ *((unsigned long *)&__m128i_result0) = 0x59f7fd8759f7fd87; ++ __m128i_out = __lsx_vaddi_wu (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6420e0208400c4c4; ++ *((unsigned long *)&__m128i_op00) = 0x20c4e0c4e0da647a; ++ *((unsigned long *)&__m128i_result1) = 0x6420e0208400c4e3; ++ *((unsigned long *)&__m128i_result0) = 0x20c4e0c4e0da6499; ++ __m128i_out = __lsx_vaddi_du (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e1d001b1a; ++ *((unsigned long *)&__m128i_op00) = 0x1918171615141312; ++ *((unsigned long *)&__m128i_result1) = 0x21201f1e1d001b25; ++ *((unsigned long *)&__m128i_result0) = 0x191817161514131d; ++ __m128i_out = __lsx_vaddi_du (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000014; ++ __m128i_out = __lsx_vaddi_du (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000004000000040; ++ *((unsigned long *)&__m128i_op00) = 0x00007770ffff9411; ++ *((unsigned long *)&__m128i_result1) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_result0) = 0x00007770ffff941d; ++ __m128i_out = __lsx_vaddi_du (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000016; ++ __m128i_out = __lsx_vaddi_du (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000080000000b; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000b; ++ __m128i_out = __lsx_vaddi_du (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-1.c +new file mode 100644 +index 000000000..b7b16a325 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-1.c +@@ -0,0 +1,335 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vaddwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fffffff80000000; ++ *((unsigned long *)&__m128i_op00) = 0x00003ffd000a4000; ++ *((unsigned long *)&__m128i_op11) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffcffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fffd000a0000; ++ __m128i_out = __lsx_vaddwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_op00) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op00) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vaddwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000490000004d; ++ *((unsigned long *)&__m128i_op00) = 0x00000001ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xff000000ff00ff00; ++ *((unsigned long *)&__m128i_op10) = 0xff00ff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000049ffffff4d; ++ *((unsigned long *)&__m128i_result0) = 0xffffff01ffffffff; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000005e695e95; ++ *((unsigned long *)&__m128i_op00) = 0x5e695e96c396b402; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000005e94; ++ *((unsigned long *)&__m128i_result0) = 0x00005e96ffffb402; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffb; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffb; ++ *((unsigned long *)&__m128i_result1) = 0x00000100000000fc; ++ *((unsigned long *)&__m128i_result0) = 0x00000100000000fc; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000158; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000005d5d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000005d5d; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5c9c9c9ce3636363; ++ *((unsigned long *)&__m128i_op00) = 0x63635c9e63692363; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffe3636363; ++ *((unsigned long *)&__m128i_result0) = 0x0000000063692363; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0202020202020203; ++ *((unsigned long *)&__m128i_op10) = 0x0202020202020203; ++ *((unsigned long *)&__m128i_result1) = 0x0000000002020202; ++ *((unsigned long *)&__m128i_result0) = 0x0000000002020202; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1817161517161514; ++ *((unsigned long *)&__m128i_op00) = 0x1615141315141312; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x76f424887fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000017161515; ++ *((unsigned long *)&__m128i_result0) = 0x0000000095141311; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000fffe; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0xfdfef9ff0efff900; ++ *((unsigned long *)&__m128i_op11) = 0xfffcfd000000fb00; ++ *((unsigned long *)&__m128i_op10) = 0x0001fe00f8000700; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000fb01; ++ *((unsigned long *)&__m128i_result0) = 0x0000000007000000; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000080806362; ++ *((unsigned long *)&__m128i_op10) = 0x807f808000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff80806362; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ff00ff; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000010002; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ff960015; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000010002; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffff960015; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_op00) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000047e59090; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffb8145f50; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00bbfff7fffffff7; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff008ff820; ++ *((unsigned long *)&__m128i_op11) = 0x00bbfff7fffffff7; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff008ff820; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffee; ++ *((unsigned long *)&__m128i_result0) = 0x00000000011ff040; ++ __m128i_out = __lsx_vaddwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x000100010001fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000100010001fffd; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffc2ffe700000007; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffc100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffc100010001; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff80df00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000dfa6e0c6; ++ *((unsigned long *)&__m128i_op10) = 0x00000000d46cdc13; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000d46cdc13; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfe813f00fe813f00; ++ *((unsigned long *)&__m128i_op10) = 0xfe813f00fe813f00; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfe813f00fe813f00; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffe; ++ __m128i_out = __lsx_vaddwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-2.c +new file mode 100644 +index 000000000..a407cadfb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-2.c +@@ -0,0 +1,344 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_op00) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x061006100613030c; ++ *((unsigned long *)&__m128i_op10) = 0x4d6814ef9c77ce46; ++ *((unsigned long *)&__m128i_result1) = 0x010f010f0112010b; ++ *((unsigned long *)&__m128i_result0) = 0x016701ee01760145; ++ __m128i_out = __lsx_vaddwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffac0a000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ac00000000; ++ __m128i_out = __lsx_vaddwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf589caff5605f2fa; ++ *((unsigned long *)&__m128i_op11) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128i_op10) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000eb00ab; ++ *((unsigned long *)&__m128i_result0) = 0x017400ff004500fa; ++ __m128i_out = __lsx_vaddwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_op00) = 0x203e16d116de012b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000017d7000001e4; ++ *((unsigned long *)&__m128i_result0) = 0x000016d10000012b; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff3fbfffff; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000100fe000100fe; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op00) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001c8520000c97d; ++ *((unsigned long *)&__m128i_result0) = 0x0001c8520001c87d; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffac0a000000; ++ *((unsigned long *)&__m128i_result1) = 0x000085af0000b000; ++ *((unsigned long *)&__m128i_result0) = 0x00017ea200002000; ++ __m128i_out = __lsx_vaddwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vaddwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000024; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000024; ++ __m128i_out = __lsx_vaddwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00307028003f80b0; ++ *((unsigned long *)&__m128i_op00) = 0x0040007fff800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000003f80b0; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff800000; ++ __m128i_out = __lsx_vaddwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vaddwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001f; ++ __m128i_out = __lsx_vaddwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0xffff80ffffff80ff; ++ *((unsigned long *)&__m128i_result1) = 0x000000018080807f; ++ *((unsigned long *)&__m128i_result0) = 0x00000001ffff80fe; ++ __m128i_out = __lsx_vaddwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffff8000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffff8000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffff8000000000; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000000010000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000180100100000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000b5207f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00001801b5307f80; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op00) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001300000013; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe218ffffea10; ++ *((unsigned long *)&__m128i_op00) = 0xfffff208fffffa02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffff208fffffa02; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000003fbf3fbf; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7ff8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000000f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff8007; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0002000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000014; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f8000007f800000; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0xffd27db010d20fbf; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0xffd27db010d20fbf; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0xffa4fb6021a41f7e; ++ __m128i_out = __lsx_vaddwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-3.c +new file mode 100644 +index 000000000..4d5c60998 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwev-3.c +@@ -0,0 +1,425 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0403cfcf01c1595e; ++ *((unsigned long *)&__m128i_op00) = 0x837cd5db43fc55d4; ++ *((unsigned long *)&__m128i_op11) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op10) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_result1) = 0x0007005200440062; ++ *((unsigned long *)&__m128i_result0) = 0x0080005e007f00d8; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffcafff8ff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000a0; ++ *((unsigned long *)&__m128i_op11) = 0xe6d4572c8a5835bc; ++ *((unsigned long *)&__m128i_op10) = 0xe5017c2ac9ca9fd0; ++ *((unsigned long *)&__m128i_result1) = 0x00d3012b015700bb; ++ *((unsigned long *)&__m128i_result0) = 0x0001002affca0070; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000fea0000fffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x6363771163631745; ++ *((unsigned long *)&__m128i_op10) = 0x636363ec6363636c; ++ *((unsigned long *)&__m128i_result1) = 0x006300fb00630143; ++ *((unsigned long *)&__m128i_result0) = 0x0063ffec0063006c; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x9c9c9c9c9c9c9c9d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0000; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8080ffffffff8080; ++ *((unsigned long *)&__m128i_op10) = 0x00008080ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xff80ffffffffff80; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff80ffffffff; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00197f26cb658837; ++ *((unsigned long *)&__m128i_op00) = 0x01009aa4a301084b; ++ *((unsigned long *)&__m128i_op11) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op10) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_result1) = 0x0037ffd40083ffe5; ++ *((unsigned long *)&__m128i_result0) = 0x001e0052001ffff9; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff00ffffff00ff; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000f50000000900; ++ *((unsigned long *)&__m128i_op10) = 0x0000090900000998; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff000900ffff98; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x10f881a20ffd02b0; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0xfff8ffa2fffdffb0; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff800000; ++ __m128i_out = __lsx_vaddwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1e0200001e020000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffcfffcfffcfffd; ++ *((unsigned long *)&__m128i_op10) = 0xfffcfffdfffcfffd; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffcfffffffd; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffdfffffffd; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff000000ff00; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_result0) = 0x0000010100000101; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op00) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000400000004; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000008; ++ *((unsigned long *)&__m128i_op10) = 0xa2f54a1ea2f54a1e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0x00004a1e00004a1e; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000868686868686; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000868600008785; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x63636b6afe486741; ++ *((unsigned long *)&__m128i_op00) = 0x41f8e880ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xe363636363abdf16; ++ *((unsigned long *)&__m128i_op10) = 0x41f8e08016161198; ++ *((unsigned long *)&__m128i_result1) = 0x0000cecd00004657; ++ *((unsigned long *)&__m128i_result0) = 0x0000c90000011197; ++ __m128i_out = __lsx_vaddwev_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001000f000e; ++ *((unsigned long *)&__m128i_op00) = 0x0000fff1000ffffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000f000e; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000ffffe; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0c07e181ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x3430af9effffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000fe00ff; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00060012000e002b; ++ *((unsigned long *)&__m128i_op10) = 0x00000049ffffffaa; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000e002b; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffaa; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000bfffffffe0f6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff7a53; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff7f80ffff7f80; ++ *((unsigned long *)&__m128i_op00) = 0xffff7f80ffff7f80; ++ *((unsigned long *)&__m128i_op11) = 0xffff7f80ffff7f80; ++ *((unsigned long *)&__m128i_op10) = 0xffff7f80ffff7f80; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fffeff00; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fffeff00; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op10) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_result1) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_result0) = 0x00000000003dffc2; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_op00) = 0x0080006b0000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000800080; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000b; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ff00ff; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000455555555; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000055555555; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff7f810100001000; ++ *((unsigned long *)&__m128i_op00) = 0x000400530050ffa6; ++ *((unsigned long *)&__m128i_op11) = 0xffff007fff810001; ++ *((unsigned long *)&__m128i_op10) = 0x000400530050ffa6; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffff811001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000a1ff4c; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_result0) = 0x000000008000001e; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op00) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_op11) = 0x86dd8341b164f12b; ++ *((unsigned long *)&__m128i_op10) = 0x9611c3985b3159f5; ++ *((unsigned long *)&__m128i_result1) = 0x0000000035697d4e; ++ *((unsigned long *)&__m128i_result0) = 0x000000013ecaadf2; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ef00ff010f; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff010f; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0xc1f03e1042208410; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001000110; ++ *((unsigned long *)&__m128i_result0) = 0x00000000431f851f; ++ __m128i_out = __lsx_vaddwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x000000030000003f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000030000003f; ++ __m128i_out = __lsx_vaddwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_op10) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffbfffffffbe; ++ __m128i_out = __lsx_vaddwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x06b1213ef1efa299; ++ *((unsigned long *)&__m128i_op00) = 0x8312f5424ca4a07f; ++ *((unsigned long *)&__m128i_op11) = 0x1f1f1f1f1f1f1f00; ++ *((unsigned long *)&__m128i_op10) = 0x1f1f1f27332b9f00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xa23214697fd03f7f; ++ __m128i_out = __lsx_vaddwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x80000000ffffd860; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff80000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff80000000; ++ __m128i_out = __lsx_vaddwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-1.c +new file mode 100644 +index 000000000..0ebe8c8a9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-1.c +@@ -0,0 +1,408 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ca354688; ++ *((unsigned long *)&__m128i_op11) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op10) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_result1) = 0x00040003ff83ff84; ++ *((unsigned long *)&__m128i_result0) = 0x00040003ff4dffca; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000040d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001f5400000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001f00000000; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000f80007; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0xb); ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff00000000; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffff0100ff; ++ *((unsigned long *)&__m128i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffefffeffff; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x478b478b38031779; ++ *((unsigned long *)&__m128i_op00) = 0x6b769e690fa1e119; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001030103; ++ *((unsigned long *)&__m128i_result1) = 0x0047004700380017; ++ *((unsigned long *)&__m128i_result0) = 0x006bff9e0010ffe2; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op00) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_op11) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op10) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_result1) = 0xff80ffa2fff0ff74; ++ *((unsigned long *)&__m128i_result0) = 0xff76ffd8ffe6ffaa; ++ __m128i_out = __lsx_vaddwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1f54e0ab00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00001f5400000000; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000000f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op00) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op11) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_op10) = 0xa352bfac9269e0aa; ++ *((unsigned long *)&__m128i_result1) = 0xffffd70b00006ea9; ++ *((unsigned long *)&__m128i_result0) = 0xffffa352ffff9269; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op00) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op11) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_op10) = 0xa352bfac9269e0aa; ++ *((unsigned long *)&__m128i_result1) = 0xffffd70b00006ea9; ++ *((unsigned long *)&__m128i_result0) = 0xffffa352ffff9269; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xe593c8c4e593c8c4; ++ *((unsigned long *)&__m128i_op11) = 0x8144ffff01c820a4; ++ *((unsigned long *)&__m128i_op10) = 0x9b2ee1a4034b4e34; ++ *((unsigned long *)&__m128i_result1) = 0xffff80c400000148; ++ *((unsigned long *)&__m128i_result0) = 0xffff80c1ffffe8de; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffefffffffe; ++ __m128i_out = __lsx_vaddwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa486c90f6537b8d7; ++ *((unsigned long *)&__m128i_op00) = 0x58bcc2013ea1cc1e; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffa486c90f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000058bcc201; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001802041b0013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x00001802041b0014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000003004; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff02000200; ++ *((unsigned long *)&__m128i_op11) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffdfff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffdfff; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fbf83468; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fbf83468; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff82bb9784; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffc6bb97ac; ++ *((unsigned long *)&__m128i_result1) = 0x000000007ffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op11) = 0x00000001000fbff9; ++ *((unsigned long *)&__m128i_op10) = 0x000000002ff9afef; ++ *((unsigned long *)&__m128i_result1) = 0x000000004f804f81; ++ *((unsigned long *)&__m128i_result0) = 0x000000004f804f80; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op10) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000020; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000fff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xfffe00029f9f6061; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x64e464e464e464e4; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffeffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000064e264e6; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0305030203020502; ++ *((unsigned long *)&__m128i_op00) = 0x0301030203020502; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000003050302; ++ *((unsigned long *)&__m128i_result0) = 0x0000000003010302; ++ __m128i_out = __lsx_vaddwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x01fc020000fe0100; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff0000ff0000; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_op10) = 0x00a6ffceffb60052; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xff84fff4ff84fff4; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000fefefe6a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c2bac2c2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fefefe6a; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0032000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0000; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5a57bacbd7e39680; ++ *((unsigned long *)&__m128i_op00) = 0x6bae051ffed76001; ++ *((unsigned long *)&__m128i_op11) = 0xf3e6586b60d7b152; ++ *((unsigned long *)&__m128i_op10) = 0xf7077b934ac0e000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4e3e133738bb47d2; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000117d00007f7b; ++ *((unsigned long *)&__m128i_op00) = 0x0000093d0000187f; ++ *((unsigned long *)&__m128i_op11) = 0x7d7f027f7c7f7c79; ++ *((unsigned long *)&__m128i_op10) = 0x7e7f7e7f027f032f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7d7f13fc7c7ffbf4; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-2.c +new file mode 100644 +index 000000000..379517f39 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-2.c +@@ -0,0 +1,344 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x08fdc221bfdb1927; ++ *((unsigned long *)&__m128i_op00) = 0x4303c67e9b7fb213; ++ *((unsigned long *)&__m128i_op11) = 0x08fdc221bfdb1927; ++ *((unsigned long *)&__m128i_op10) = 0x4303c67e9b7fb213; ++ *((unsigned long *)&__m128i_result1) = 0x00100184017e0032; ++ *((unsigned long *)&__m128i_result0) = 0x0086018c01360164; ++ __m128i_out = __lsx_vaddwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff77777807777775; ++ *((unsigned long *)&__m128i_op00) = 0xe6eeef00eeeeeebf; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000f00f; ++ *((unsigned long *)&__m128i_result1) = 0x00ff007700070077; ++ *((unsigned long *)&__m128i_result0) = 0x00e600ef00ee01de; ++ __m128i_out = __lsx_vaddwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vaddwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vaddwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000030000003f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4429146a7b4c88b2; ++ *((unsigned long *)&__m128i_op10) = 0xe22b3595efa4aa0c; ++ *((unsigned long *)&__m128i_result1) = 0x0000442900007b4c; ++ *((unsigned long *)&__m128i_result0) = 0x0000e22b0000efa4; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_result1) = 0x0000000600000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000636500006363; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000a6; ++ *((unsigned long *)&__m128i_result1) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_result0) = 0x0000080800000808; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000000000; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0001fffe0001fefc; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0001fffe0001fefc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000002; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fff80000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xff8000010f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff8000010f78; ++ __m128i_out = __lsx_vaddwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffc01; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffc01; ++ *((unsigned long *)&__m128i_result1) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x00000001fffffffe; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op11) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op10) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_result1) = 0x000000006e17bfd8; ++ *((unsigned long *)&__m128i_result0) = 0x000000006e17bfd8; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f000400000003; ++ *((unsigned long *)&__m128i_op00) = 0x003f000400000003; ++ *((unsigned long *)&__m128i_op11) = 0x0001000000010000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000400004; ++ *((unsigned long *)&__m128i_result0) = 0x00000000003f0004; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000017f800001; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000017f800001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000007f800001; ++ *((unsigned long *)&__m128i_result0) = 0x000000007f800001; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000000; ++ __m128i_out = __lsx_vaddwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x379674c000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3789f68000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x379674c000000000; ++ __m128i_out = __lsx_vaddwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-3.c +new file mode 100644 +index 000000000..30dc83518 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vaddwod-3.c +@@ -0,0 +1,237 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000a16316b0; ++ *((unsigned long *)&__m128i_op10) = 0x16161616a16316b0; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ffffa10016; ++ *((unsigned long *)&__m128i_result0) = 0x01150115ffa10016; ++ __m128i_out = __lsx_vaddwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007e007e007e007e; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vaddwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000120002000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000200020; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000003f; ++ __m128i_out = __lsx_vaddwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000fe00fe; ++ *((unsigned long *)&__m128i_result0) = 0x00fe00fe00fe00fe; ++ __m128i_out = __lsx_vaddwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000011ffee; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000dfff2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ff; ++ __m128i_out = __lsx_vaddwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00e0000000e00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000e0000000e0; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff7100fffc; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00ff00ffffa10016; ++ *((unsigned long *)&__m128i_op10) = 0x01150115ffa10016; ++ *((unsigned long *)&__m128i_result1) = 0x000100fe000070a1; ++ *((unsigned long *)&__m128i_result0) = 0x00000115ffffffa1; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fffe0000fffe; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe218ffffea10; ++ *((unsigned long *)&__m128i_op00) = 0xfffff208fffffa02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000001000f00fe00; ++ *((unsigned long *)&__m128i_op10) = 0x0000017fff00fe7f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000f00; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffff00; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x5); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x04faf60009f5f092; ++ *((unsigned long *)&__m128i_op00) = 0x04fafa9200000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfff9fffefff9ffff; ++ *((unsigned long *)&__m128i_result1) = 0x000004fa000009f5; ++ *((unsigned long *)&__m128i_result0) = 0x000004f3fffffff9; ++ __m128i_out = __lsx_vaddwod_w_hu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000c2f90000bafa; ++ *((unsigned long *)&__m128i_op00) = 0x8000c2fa8000c2fa; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000c2f90000bafa; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00001fff00001fff; ++ *((unsigned long *)&__m128i_op00) = 0x00000003fffffffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00001fff00001fff; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000807bf0a1f80; ++ *((unsigned long *)&__m128i_op00) = 0x00000800ecedee68; ++ *((unsigned long *)&__m128i_op11) = 0x5847b72626ce61ef; ++ *((unsigned long *)&__m128i_op10) = 0x110053f401e7cced; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x5847bf2de5d8816f; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000155; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vaddwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-1.c +new file mode 100644 +index 000000000..af75f8e4e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-1.c +@@ -0,0 +1,488 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x4ee85545068f3133; ++ *((unsigned long *)&__m128i_op00) = 0x870968c1f56bb3cd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x004e005500060031; ++ *((unsigned long *)&__m128i_result0) = 0xff870068fff5ffb3; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff082f000000000; ++ *((unsigned long *)&__m128i_op00) = 0x003f000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc04d600d3aded151; ++ *((unsigned long *)&__m128i_op10) = 0xc000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x004cff8fffde0051; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x800000007fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x800000007fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x003f0000ffffffff; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0042003e0042002f; ++ *((unsigned long *)&__m128i_op10) = 0x0001fffc0001fffc; ++ *((unsigned long *)&__m128i_result1) = 0x0042003e0042002f; ++ *((unsigned long *)&__m128i_result0) = 0x0001fffc0001fffc; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7505443065413aed; ++ *((unsigned long *)&__m128i_op00) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000750500006541; ++ *((unsigned long *)&__m128i_result0) = 0x00000100fffffefd; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00ffff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffe000000f6; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x00000001fffffffe; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x4050000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000f80007; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000f8; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80ffffffffff80; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff80ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fffffffe; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xce9035c49ffff570; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op10) = 0xce9035c49ffff574; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result0) = 0x00000454ffff9573; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80007fc000003f00; ++ *((unsigned long *)&__m128i_op00) = 0x7d187e427c993f80; ++ *((unsigned long *)&__m128i_op11) = 0x7500000075000000; ++ *((unsigned long *)&__m128i_op10) = 0x7500000075000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00007d1800007c99; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x5555000054100000; ++ *((unsigned long *)&__m128i_op10) = 0x5555000154100155; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000155; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffebe6ed565; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffebe6ed565; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffbe6ed563; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x78c00000ff000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000078c00000; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7d3ac60000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007d3ac600; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffff82bb9784; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffffc6bb97ac; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff82bb9784; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffc6bb97ac; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000003effff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000003effff; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xf359f359f359f359; ++ *((unsigned long *)&__m128i_op10) = 0xf359f359f359f359; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffff359f358; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffff359f358; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000e2e36363; ++ *((unsigned long *)&__m128i_result0) = 0x0000000063636363; ++ __m128i_out = __lsx_vhaddw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op00) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff02000200; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffe00001ffe200; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000383; ++ *((unsigned long *)&__m128i_op00) = 0xe400000003ffc001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op10) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffe000ffff2382; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03574e39e496cbc9; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x03574e38e496cbc9; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xabff54e911f71b07; ++ *((unsigned long *)&__m128i_op00) = 0xa9ec4882f216ea11; ++ *((unsigned long *)&__m128i_op11) = 0xfc01fcfefc02fdf7; ++ *((unsigned long *)&__m128i_op10) = 0xfe00fcfffe01fd01; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xaa0051e90ff91808; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffe00000001; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x000000030000003f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000030000003f; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffff000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op10) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff0001ffff9514; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x9c9c9c9c9c9c9c9c; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000400000001; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80ff807e017f01; ++ *((unsigned long *)&__m128i_op00) = 0x7f3b7f3f7f3b7f21; ++ *((unsigned long *)&__m128i_op11) = 0x0a0000001e000000; ++ *((unsigned long *)&__m128i_op10) = 0x0a000000f6000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0980ff8174017f01; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op10) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000ef0000000003b; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000011ff040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000011ff040; ++ __m128i_out = __lsx_vhaddw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-2.c +new file mode 100644 +index 000000000..37c769a2d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhaddw-2.c +@@ -0,0 +1,452 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fff80000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ff0000; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0080000000000000; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op00) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0052005200520052; ++ *((unsigned long *)&__m128i_result0) = 0x0052005200520052; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000fffd; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff000000ff; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00060012000e002b; ++ *((unsigned long *)&__m128i_op00) = 0x00000049ffffffaa; ++ *((unsigned long *)&__m128i_op11) = 0x000000060000000e; ++ *((unsigned long *)&__m128i_op10) = 0x000000127fffffea; ++ *((unsigned long *)&__m128i_result1) = 0x000000060000000e; ++ *((unsigned long *)&__m128i_result0) = 0x0000001201fe01e9; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007f008000ea007f; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00009f0000009f00; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000bd3d00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000bd3d00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000bd3d00000000; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_op11) = 0xffff007f00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff007f00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000007f00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000007f00000000; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ef400ad21fc7081; ++ *((unsigned long *)&__m128i_op10) = 0x28bf0351ec69b5f2; ++ *((unsigned long *)&__m128i_result1) = 0x000000ad00007081; ++ *((unsigned long *)&__m128i_result0) = 0x000003510000b5f2; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x5252adadadadadad; ++ *((unsigned long *)&__m128i_op10) = 0xadad52525252adad; ++ *((unsigned long *)&__m128i_result1) = 0x0000adad0000adad; ++ *((unsigned long *)&__m128i_result0) = 0x000052520000adad; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff8000010f78; ++ *((unsigned long *)&__m128i_op11) = 0x002a001a001a000b; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001a0000000b; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7500000075007500; ++ *((unsigned long *)&__m128i_op00) = 0x00feff8000ff80ff; ++ *((unsigned long *)&__m128i_op11) = 0xffff800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00007d1800007c99; ++ *((unsigned long *)&__m128i_result1) = 0x0000f50000007500; ++ *((unsigned long *)&__m128i_result0) = 0x00007e1600007d98; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff760386bdae46; ++ *((unsigned long *)&__m128i_op00) = 0xc1fc7941bc7e00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0802080408060803; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff000086bd; ++ *((unsigned long *)&__m128i_result0) = 0x0000ca000000c481; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000007fff9; ++ *((unsigned long *)&__m128i_op11) = 0xffff2356fe165486; ++ *((unsigned long *)&__m128i_op10) = 0x5efeb3165bd7653d; ++ *((unsigned long *)&__m128i_result1) = 0x0000235600005486; ++ *((unsigned long *)&__m128i_result0) = 0x0000b31600006544; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c83e21a22001818; ++ *((unsigned long *)&__m128i_op00) = 0xdd3b8b02563b2d7b; ++ *((unsigned long *)&__m128i_op11) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op10) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result1) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128i_result0) = 0x00012c8a0000a58a; ++ __m128i_out = __lsx_vhaddw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa8beed87bc3f2be1; ++ *((unsigned long *)&__m128i_op00) = 0x0024d8f6a494006a; ++ *((unsigned long *)&__m128i_op11) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000001a8beed86; ++ *((unsigned long *)&__m128i_result0) = 0x000000010024d8f5; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000078c00000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x6a57a30ff0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x00000000f0000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000040d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x00000001fffffffe; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x80000000b57ec564; ++ *((unsigned long *)&__m128i_op10) = 0x8000000083ff0be0; ++ *((unsigned long *)&__m128i_result1) = 0x00000001b57ec563; ++ *((unsigned long *)&__m128i_result0) = 0x0000000183ff0bdf; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000e2e3ffffd1d3; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000008000e2e3; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200010002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200010002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000010004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000001000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x4ee85545ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x870968c1f56bb3cd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x870968c1f56bb3cd; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000013d; ++ *((unsigned long *)&__m128i_op11) = 0x0010001000030000; ++ *((unsigned long *)&__m128i_op10) = 0x0006000200000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0006000200000000; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffe; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op11) = 0x00000000001b0000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000001b0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000001b001b; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000004870ba0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000004870ba0; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000010000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000010000000; ++ *((unsigned long *)&__m128i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff8000010f800000; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00007fff7fff8000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000003e2; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhaddw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmadd.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmadd.c +new file mode 100644 +index 000000000..3fade5157 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmadd.c +@@ -0,0 +1,450 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffa486c90f; ++ *((unsigned long *)&__m128i_op20) = 0x1f52d710bf295626; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff7f01ff01; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x78c00000ff000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff7f01ff01; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfa31dfa21672e711; ++ *((unsigned long *)&__m128i_op10) = 0x1304db85e468073a; ++ *((unsigned long *)&__m128i_op21) = 0x887c8beb969e00f2; ++ *((unsigned long *)&__m128i_op20) = 0x101f8b680b6f8095; ++ *((unsigned long *)&__m128i_result1) = 0x7582ed22cb1c6e12; ++ *((unsigned long *)&__m128i_result0) = 0x35aaa61c944f34c2; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op00) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_result0) = 0x5252525252525252; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xc); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op21) = 0xbfffbfffbfffbffe; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4000400040004002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe01fe01fe01fe01; ++ *((unsigned long *)&__m128i_op00) = 0xfe01fe01fe01fe01; ++ *((unsigned long *)&__m128i_op11) = 0xfe01fe01fe01fe01; ++ *((unsigned long *)&__m128i_op10) = 0xfe01fe01fe01fe01; ++ *((unsigned long *)&__m128i_op21) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op20) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result1) = 0xf10cf508f904fd01; ++ *((unsigned long *)&__m128i_result0) = 0xf10cf508f904fd01; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffb080ffffb080; ++ *((unsigned long *)&__m128i_op10) = 0xffffb080ffffb080; ++ *((unsigned long *)&__m128i_op21) = 0x004fcfcfd01f9f9f; ++ *((unsigned long *)&__m128i_op20) = 0x9f4fcfcfcf800000; ++ *((unsigned long *)&__m128i_result1) = 0x3504b5fd2dee1f80; ++ *((unsigned long *)&__m128i_result0) = 0x4676f70fc0000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf7f7f7ff8e8c6d7e; ++ *((unsigned long *)&__m128i_op00) = 0xf7f7f7f7f7f7fbff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xf7f7f7ff8e8c6d7e; ++ *((unsigned long *)&__m128i_result0) = 0xf7f7f7f7f7f7fbff; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op11) = 0x0fbc1df53c1ae3f9; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ff820f81; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xf144e32bc4e61d27; ++ *((unsigned long *)&__m128i_result0) = 0x00000020017ef19f; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000004b01; ++ *((unsigned long *)&__m128i_op11) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000a0; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000004b01; ++ __m128i_out = __lsx_vmadd_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op20) = 0x0000ffff0000ff00; ++ *((unsigned long *)&__m128i_result1) = 0xffffffefffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m128i_op21) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_op20) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xf001f0010101f002; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000fffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0010000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000007f41; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000fffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0010000000000001; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x01ff020000ff03ff; ++ *((unsigned long *)&__m128i_op00) = 0x01346b8d00b04c5a; ++ *((unsigned long *)&__m128i_op11) = 0x002affd600000001; ++ *((unsigned long *)&__m128i_op10) = 0xcbc2723a4f12a5f8; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x01ff020000ff03ff; ++ *((unsigned long *)&__m128i_result0) = 0x01346b8d00b04c5a; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080808000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080808000; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000455555555; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000455555555; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007f00ff00ff00fe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_op20) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_result1) = 0x007f00ff00ff00fe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xdcec560380000000; ++ *((unsigned long *)&__m128i_op00) = 0x08ec7f7f80000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_op21) = 0x32d8f0a905b6c59b; ++ *((unsigned long *)&__m128i_op20) = 0x322a52fc2ba83b96; ++ *((unsigned long *)&__m128i_result1) = 0xaa14efac3bb62636; ++ *((unsigned long *)&__m128i_result0) = 0xd6c22c8353a80d2c; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmadd_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op20) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xff000000001f1f00; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00009c7c00007176; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00060fbf00040fbf; ++ *((unsigned long *)&__m128i_op00) = 0x00020fbf00000fbf; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x9727b8499727b849; ++ *((unsigned long *)&__m128i_op20) = 0x12755900b653f081; ++ *((unsigned long *)&__m128i_result1) = 0x00060fbf00040fbf; ++ *((unsigned long *)&__m128i_result0) = 0x00020fbf00000fbf; ++ __m128i_out = __lsx_vmadd_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000021100000211; ++ *((unsigned long *)&__m128i_op00) = 0xfb141d31fb141d31; ++ *((unsigned long *)&__m128i_op11) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op10) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op21) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_op20) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_result1) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_result0) = 0xbbc8ecc5f3ced5f3; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0674c886fcba4e98; ++ *((unsigned long *)&__m128i_op00) = 0xfdce8003090b0906; ++ *((unsigned long *)&__m128i_op11) = 0x003fffc0ffc0003f; ++ *((unsigned long *)&__m128i_op10) = 0xffc0ffc0003f003f; ++ *((unsigned long *)&__m128i_op21) = 0x002a05a2f059094a; ++ *((unsigned long *)&__m128i_op20) = 0x05ad3ba576eae048; ++ *((unsigned long *)&__m128i_result1) = 0xd4a6cc27d02397ce; ++ *((unsigned long *)&__m128i_result0) = 0x24b85f887e903abe; ++ __m128i_out = __lsx_vmadd_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0700f8ff0700f8ff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000007020701; ++ *((unsigned long *)&__m128i_op20) = 0x0000000007010701; ++ *((unsigned long *)&__m128i_result1) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result0) = 0x7f8000008680f1ff; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636463abdf17; ++ *((unsigned long *)&__m128i_op00) = 0x41f8e08016161198; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x6363636463abdf17; ++ *((unsigned long *)&__m128i_result0) = 0x41f8e08016161198; ++ __m128i_out = __lsx_vmadd_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffff00ff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_op11) = 0x17c64aaef639f093; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_op20) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_result1) = 0x10f881a20ffd02b0; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff800000; ++ __m128i_out = __lsx_vmadd_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-1.c +new file mode 100644 +index 000000000..d3fd83da7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-1.c +@@ -0,0 +1,472 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000036de0000; ++ *((unsigned long *)&__m128i_op10) = 0x000000003be14000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op20) = 0x00000000ffff7a53; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000001f0000; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001f0a; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000cdc1; ++ *((unsigned long *)&__m128i_op11) = 0xe93d0bd19ff0c170; ++ *((unsigned long *)&__m128i_op10) = 0x5237c1bac9eadf55; ++ *((unsigned long *)&__m128i_op21) = 0x05d0ae6002e8748e; ++ *((unsigned long *)&__m128i_op20) = 0xcd1de80217374041; ++ *((unsigned long *)&__m128i_result1) = 0xf490ee600180ce20; ++ *((unsigned long *)&__m128i_result0) = 0x063bff74fb46e356; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op21) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op20) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_result1) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_result0) = 0x0fff0fff0fff0fff; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result0) = 0x6363636363636363; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xfffe00029f9f6061; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3f5ec0a0feefa0b0; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x000000007fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xfffe00029fb060b1; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x3); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff8; ++ *((unsigned long *)&__m128i_op11) = 0x8d78336c83652b86; ++ *((unsigned long *)&__m128i_op10) = 0x39c51f389c0d6112; ++ *((unsigned long *)&__m128i_op21) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffff0001ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ff9b0082; ++ *((unsigned long *)&__m128i_result0) = 0x003a0037fff2fff8; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op00) = 0x05fafe0101fe000e; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op10) = 0x05fafe0101fe000e; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_result0) = 0x05fafe0101fe000e; ++ __m128i_out = __lsx_vmaddwev_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff82bb9784; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffc6bb97ac; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x7fffffff82bb9784; ++ *((unsigned long *)&__m128i_op20) = 0x7fffffffc6bb97ac; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff82bb9784; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffc6bb97ac; ++ __m128i_out = __lsx_vmaddwev_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x05d0ba0002e8802e; ++ *((unsigned long *)&__m128i_op00) = 0xd005e802174023d6; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xc000c000c000ff81; ++ *((unsigned long *)&__m128i_op21) = 0x0ba00ba00ba00ba0; ++ *((unsigned long *)&__m128i_op20) = 0x0ba00ba00ba011eb; ++ *((unsigned long *)&__m128i_result1) = 0x05d0ae6002e8748e; ++ *((unsigned long *)&__m128i_result0) = 0xcd1de80217374041; ++ __m128i_out = __lsx_vmaddwev_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_op10) = 0x00ff00ff00fe00ff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00000fff00000e36; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000fef01000e27ca; ++ __m128i_out = __lsx_vmaddwev_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op10) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op21) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op20) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vmaddwev_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x680485c8b304b019; ++ *((unsigned long *)&__m128i_op00) = 0xc89d7f0fed582019; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_op21) = 0x67157b5100005000; ++ *((unsigned long *)&__m128i_op20) = 0x387c7e0a133f2000; ++ *((unsigned long *)&__m128i_result1) = 0x680485c8b304b019; ++ *((unsigned long *)&__m128i_result0) = 0xc89d7f0ff90da019; ++ __m128i_out = __lsx_vmaddwev_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_op10) = 0x01fc020000fe0100; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100fe000100fe; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x000100fe000100fe; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xa23214697fd03f7f; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7c7c9c0000007176; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7c7c9c0000007176; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x022002101b200203; ++ *((unsigned long *)&__m128i_op00) = 0x022002101b200203; ++ *((unsigned long *)&__m128i_op11) = 0x022002101b200203; ++ *((unsigned long *)&__m128i_op10) = 0x022002101b200203; ++ *((unsigned long *)&__m128i_op21) = 0x000000080c43b700; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x036caeeca7592703; ++ *((unsigned long *)&__m128i_result0) = 0x022002101b200203; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x9c83e21a22001818; ++ *((unsigned long *)&__m128i_op10) = 0xdd3b8b02563b2d7b; ++ *((unsigned long *)&__m128i_op21) = 0x000000009c83e21a; ++ *((unsigned long *)&__m128i_op20) = 0x0000000022001818; ++ *((unsigned long *)&__m128i_result1) = 0xf2c97aaa7d8fa270; ++ *((unsigned long *)&__m128i_result0) = 0x0b73e427f7cfcb88; ++ __m128i_out = __lsx_vmaddwev_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0010001000030000; ++ *((unsigned long *)&__m128i_op00) = 0x0006000200000000; ++ *((unsigned long *)&__m128i_op11) = 0x7505445465593af1; ++ *((unsigned long *)&__m128i_op10) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000030000; ++ *((unsigned long *)&__m128i_result0) = 0x0006000200000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0003000000010000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000780000007800; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0007000000040000; ++ *((unsigned long *)&__m128i_result0) = 0x0003000000010000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf047ef0000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff80800001; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff80800001; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffff7fff7ef; ++ *((unsigned long *)&__m128i_op10) = 0x80808080ffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_op20) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_result1) = 0xfffffbff8888080a; ++ *((unsigned long *)&__m128i_result0) = 0x080803ff807ff7f9; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fc03fc000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7f801fe000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x3fc03fc000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f801fe000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x01fe01fd01fd01fd; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x5d7f5d007f6a007f; ++ *((unsigned long *)&__m128i_op20) = 0x7fff7fff7fff7f00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000060000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000500000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000060000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m128i_op20) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-2.c +new file mode 100644 +index 000000000..839285685 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-2.c +@@ -0,0 +1,383 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff00000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x7fffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7e00fe0000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffbffffff85; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffc0000fdfc; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3941248880000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3941248880000000; ++ *((unsigned long *)&__m128i_op21) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x40f3fa0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x76f4248880000000; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000e36400005253; ++ *((unsigned long *)&__m128i_op20) = 0x000035ed0000e000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x400000003fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x4000000040000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x400000003fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x4000000040000000; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf1f1f1f149ed7273; ++ *((unsigned long *)&__m128i_op00) = 0x78508ad4ec2ffcde; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffdfdc0d; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00000000ffdfdc0d; ++ *((unsigned long *)&__m128i_result1) = 0xf1f1f1f149ed7273; ++ *((unsigned long *)&__m128i_result0) = 0x78508ad4ae70fd87; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000440efffff000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000003b; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op21) = 0x440ef000440ef000; ++ *((unsigned long *)&__m128i_op20) = 0x4400000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000440efffff000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000003b; ++ __m128i_out = __lsx_vmaddwev_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000ffc2f; ++ *((unsigned long *)&__m128i_op00) = 0x00201df000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffc2ffe700000007; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffc100010001; ++ *((unsigned long *)&__m128i_op21) = 0x00010020fffeffde; ++ *((unsigned long *)&__m128i_op20) = 0x011f57c100201a46; ++ *((unsigned long *)&__m128i_result1) = 0x001ffce00016fb41; ++ *((unsigned long *)&__m128i_result0) = 0x57cb857100001a46; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7c7c9c0000007176; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x00ff000000001f1f; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7c7c9c0000007176; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_op00) = 0xc5c53492f25acbf2; ++ *((unsigned long *)&__m128i_op11) = 0xff000000001f1f00; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_result0) = 0xc5c53492f25acbf2; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x34947b4b11684f92; ++ *((unsigned long *)&__m128i_op00) = 0xd73691661e5b68b4; ++ *((unsigned long *)&__m128i_op11) = 0x000016f303dff6d2; ++ *((unsigned long *)&__m128i_op10) = 0x000016f303dff6d2; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x7fffffff00000001; ++ *((unsigned long *)&__m128i_result1) = 0x34947b4b11684f92; ++ *((unsigned long *)&__m128i_result0) = 0xee297a731e5c5f86; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0177fff0fffffff0; ++ *((unsigned long *)&__m128i_op10) = 0x00000000011ff8bc; ++ *((unsigned long *)&__m128i_op21) = 0x00bbfff7fffffff7; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff008ff820; ++ *((unsigned long *)&__m128i_result1) = 0xffe8008fffe7008f; ++ *((unsigned long *)&__m128i_result0) = 0x00010001f1153780; ++ __m128i_out = __lsx_vmaddwev_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000021; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010002; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010002; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op21) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op20) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0001808281820102; ++ *((unsigned long *)&__m128i_result0) = 0x0001808201018081; ++ __m128i_out = __lsx_vmaddwev_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000010100fe0101; ++ *((unsigned long *)&__m128i_op20) = 0xffff0200ffff01ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op21) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007f7f80807f7f80; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000020302030; ++ *((unsigned long *)&__m128i_op10) = 0x0000000020302030; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x3fffffffc0000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000006e17bfd8; ++ *((unsigned long *)&__m128i_op00) = 0x000000006e17bfd8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffff0100000001; ++ *((unsigned long *)&__m128i_op20) = 0xffffff0100000001; ++ *((unsigned long *)&__m128i_result1) = 0x000000006e17bfd8; ++ *((unsigned long *)&__m128i_result0) = 0x000000006e17bfd8; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op21) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op20) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x00010000fffffffc; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000008000e2e3; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000008000e2e3; ++ *((unsigned long *)&__m128i_op10) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080806362; ++ *((unsigned long *)&__m128i_result0) = 0x807f808000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffa; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8101010181010101; ++ *((unsigned long *)&__m128i_op10) = 0x8101010181010101; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op21) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000101010015; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffed00010001; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-3.c +new file mode 100644 +index 000000000..bab2c6cf3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwev-3.c +@@ -0,0 +1,383 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xc0c00000c0c00000; ++ *((unsigned long *)&__m128i_op20) = 0xc0c00c01c2cd0009; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f78787f00f7f700; ++ *((unsigned long *)&__m128i_op10) = 0x0000f7f700f7f700; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000400; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x000000000000040d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000080003f80ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op21) = 0x3ff0010000000000; ++ *((unsigned long *)&__m128i_op20) = 0x3ff0010000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000080003f80ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xff81ff82ff810081; ++ *((unsigned long *)&__m128i_op20) = 0xff82ff810081ff81; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffff8000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffff8000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff8000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x841f000fc28f801f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x841f000fc28f801f; ++ *((unsigned long *)&__m128i_op21) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op20) = 0xe593c8c4e593c8c4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x76ecfc8b85ac78db; ++ __m128i_out = __lsx_vmaddwev_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000fff3; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x000000000000040d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010400; ++ __m128i_out = __lsx_vmaddwev_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op20) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100013fa0; ++ __m128i_out = __lsx_vmaddwev_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000002b0995850; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff80005613; ++ *((unsigned long *)&__m128i_op10) = 0x007f800000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffff80005613; ++ *((unsigned long *)&__m128i_op20) = 0x007f800000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff00011cf0c569; ++ *((unsigned long *)&__m128i_result0) = 0xc0000002b0995850; ++ __m128i_out = __lsx_vmaddwev_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x000000ffffff81fe; ++ *((unsigned long *)&__m128i_op10) = 0xffffff00ffff7e01; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x000000fffe01fd02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00fe00fffe86f901; ++ __m128i_out = __lsx_vmaddwev_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000004000; ++ *((unsigned long *)&__m128i_op10) = 0xfff8004000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbfffbfffbfffbffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xbfffbfffbfffbffe; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xbfffbfffbfffbffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffd3000000130000; ++ *((unsigned long *)&__m128i_op00) = 0xffd3000000130000; ++ *((unsigned long *)&__m128i_op11) = 0xffd3000000130000; ++ *((unsigned long *)&__m128i_op10) = 0xffd3000000130000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffd3000000130000; ++ *((unsigned long *)&__m128i_result0) = 0xffd3000000130000; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op10) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op21) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op20) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_result1) = 0x00000f02e1f80f04; ++ *((unsigned long *)&__m128i_result0) = 0x00000f02e1f80f04; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffefffe00000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffe00000000; ++ *((unsigned long *)&__m128i_op11) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_op10) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_op21) = 0x5a57bacbd7e39680; ++ *((unsigned long *)&__m128i_op20) = 0x6bae051ffed76001; ++ *((unsigned long *)&__m128i_result1) = 0xf3eb458161080000; ++ *((unsigned long *)&__m128i_result0) = 0xffe9454286c0e000; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0051005200510052; ++ *((unsigned long *)&__m128i_op10) = 0x0051005200510052; ++ *((unsigned long *)&__m128i_op21) = 0xffaeffaeffaeffae; ++ *((unsigned long *)&__m128i_op20) = 0xffaeffaeffaeffae; ++ *((unsigned long *)&__m128i_result1) = 0xffffe65ecc1be5bc; ++ *((unsigned long *)&__m128i_result0) = 0xffffe65ecc1be5bc; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf1f1f1f149ed7273; ++ *((unsigned long *)&__m128i_op00) = 0xf1f1f1f1865e65a1; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff941d; ++ *((unsigned long *)&__m128i_op21) = 0xf1f1f1f149ed7273; ++ *((unsigned long *)&__m128i_op20) = 0xf1f1f1f1865e65a1; ++ *((unsigned long *)&__m128i_result1) = 0xf1f1f1f149ed7273; ++ *((unsigned long *)&__m128i_result0) = 0x78508ad4ec2ffcde; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x000000120000000d; ++ *((unsigned long *)&__m128i_op20) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_result1) = 0x0001000cfffffff2; ++ *((unsigned long *)&__m128i_result0) = 0x0001000dfffffff1; ++ __m128i_out = __lsx_vmaddwev_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op00) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op11) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op10) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op21) = 0xff80ffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x7ffffffeffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000002fe800000ff; ++ *((unsigned long *)&__m128i_result0) = 0x7ffffe0100000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff00000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfe80000000000001; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op20) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-1.c +new file mode 100644 +index 000000000..5875aa597 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-1.c +@@ -0,0 +1,372 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000010000000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_op11) = 0x0000000c7fff000c; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op21) = 0xfffff000f0008d3c; ++ *((unsigned long *)&__m128i_op20) = 0xfffff0016fff8d3d; ++ *((unsigned long *)&__m128i_result1) = 0x00000100f8100002; ++ *((unsigned long *)&__m128i_result0) = 0xfff0ff8006f0f950; ++ __m128i_out = __lsx_vmaddwod_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x007ffd0001400840; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007ffd0001400840; ++ __m128i_out = __lsx_vmaddwod_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op21) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000002000; ++ __m128i_out = __lsx_vmaddwod_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010058; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010058; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffac0a000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000200000001b; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffac0a000000; ++ __m128i_out = __lsx_vmaddwod_h_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000017fda829; ++ __m128i_out = __lsx_vmaddwod_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xff8000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x000800000000ffff; ++ *((unsigned long *)&__m128i_op21) = 0x697eba2bedfa9c82; ++ *((unsigned long *)&__m128i_op20) = 0xd705c77a7025c899; ++ *((unsigned long *)&__m128i_result1) = 0xffcb410000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffeb827ffffffff; ++ __m128i_out = __lsx_vmaddwod_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffffc00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fffffc00; ++ __m128i_out = __lsx_vmaddwod_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000f; ++ *((unsigned long *)&__m128i_op11) = 0x000000c5ac01015b; ++ *((unsigned long *)&__m128i_op10) = 0xaaacac88a3a9a96a; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000f; ++ __m128i_out = __lsx_vmaddwod_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ef4002d21fc7001; ++ *((unsigned long *)&__m128i_op00) = 0x28bf02d1ec6a35b2; ++ *((unsigned long *)&__m128i_op11) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_op10) = 0xffff6080ffff4417; ++ *((unsigned long *)&__m128i_op21) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op20) = 0xff8000007fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x7ef400ad21fc7081; ++ *((unsigned long *)&__m128i_result0) = 0x28bf0351ec69b5f2; ++ __m128i_out = __lsx_vmaddwod_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001200100012001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xbf80000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1040400000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0961000100000001; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m128i_op11) = 0x7da9b23a624082fd; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x03574e39e496cbc9; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001010000; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff01018888; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000030000003f; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3f77aab500000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffc100010001; ++ *((unsigned long *)&__m128i_op21) = 0x3f77aab500000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000ffc100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0fbc1df53c1ae3f9; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff820f81; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_op21) = 0x00000000ff801c9e; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000810000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000700000004e000; ++ *((unsigned long *)&__m128i_op00) = 0x0003000000012020; ++ *((unsigned long *)&__m128i_op11) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x00000000e00a18f5; ++ *((unsigned long *)&__m128i_op20) = 0x000000002023dcdc; ++ *((unsigned long *)&__m128i_result1) = 0x000700000004e000; ++ *((unsigned long *)&__m128i_result0) = 0x0003000000012020; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000120000000d; ++ *((unsigned long *)&__m128i_op10) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_op21) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000011ffee; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000dfff2; ++ __m128i_out = __lsx_vmaddwod_d_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffff7fffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffff8000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffff7fffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffff8000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000003fff; ++ *((unsigned long *)&__m128i_result0) = 0x7ff8010000000001; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_result0) = 0x01fc020000fe0100; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x78c00000ff000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x78c00000ff000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x78c00000ff000000; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_op11) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x1000100012030e02; ++ *((unsigned long *)&__m128i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_result0) = 0xfefefefefefefefe; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_op00) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x010105017878f8f6; ++ *((unsigned long *)&__m128i_op20) = 0xf8f8fd0180810907; ++ *((unsigned long *)&__m128i_result1) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_result0) = 0x0000080800000808; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010058; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000158; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x328e1080889415a0; ++ *((unsigned long *)&__m128i_op00) = 0x3960b1a401811060; ++ *((unsigned long *)&__m128i_op11) = 0x328e1080889415a0; ++ *((unsigned long *)&__m128i_op10) = 0x3960b1a401811060; ++ *((unsigned long *)&__m128i_op21) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x32f3c7a38f9f4b8b; ++ *((unsigned long *)&__m128i_result0) = 0x2c9e5069f5d57780; ++ __m128i_out = __lsx_vmaddwod_q_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-2.c +new file mode 100644 +index 000000000..4be7fce82 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-2.c +@@ -0,0 +1,438 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xd8248069ffe78077; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0d0d0d0d0d0d0d0d; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xd8248069ffe78077; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xe31c86e90cda86f7; ++ __m128i_out = __lsx_vmaddwod_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00010020fffeffde; ++ *((unsigned long *)&__m128i_op00) = 0x0100400100200e68; ++ *((unsigned long *)&__m128i_op11) = 0x00010020fffeffde; ++ *((unsigned long *)&__m128i_op10) = 0x0100400100200e68; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x1ff85ffe2ae5d973; ++ *((unsigned long *)&__m128i_result1) = 0x00010020fffeffde; ++ *((unsigned long *)&__m128i_result0) = 0x011f57c100201a46; ++ __m128i_out = __lsx_vmaddwod_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbafebb00ffd500fe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0c0b0a090b0a0908; ++ *((unsigned long *)&__m128i_op10) = 0x0a09080709080706; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmaddwod_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffc0800000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffc0800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffc0800000; ++ __m128i_out = __lsx_vmaddwod_h_bu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_op00) = 0x003dbe88077c78c1; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op20) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_result0) = 0x003dc288077c7cc1; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffc0000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000455555555; ++ *((unsigned long *)&__m128i_result1) = 0xffc0000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffc0000000000004; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000053a; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000036280001; ++ *((unsigned long *)&__m128i_op00) = 0x42a0000042a02001; ++ *((unsigned long *)&__m128i_op11) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_op10) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000036280001; ++ *((unsigned long *)&__m128i_result0) = 0x42a0000042a02001; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000ff00fe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000fe00ff; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffff946c; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffff946b; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff3c992b2e; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff730f; ++ *((unsigned long *)&__m128i_op21) = 0x00000000ffff946c; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffff946b; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffff946c; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffdffff946c; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000401000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000080000000000; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffff800; ++ *((unsigned long *)&__m128i_op00) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffff800; ++ *((unsigned long *)&__m128i_result0) = 0x00ff000000ff0000; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0006ffff0004ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0002ffff0000ffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff7f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002fffefffd0001; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffe000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c6fde000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xe000e0006080b040; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffe000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c6fde000; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x021b7d24c9678a35; ++ *((unsigned long *)&__m128i_op10) = 0x030298a6a1030a49; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_op00) = 0x0a753500950fa306; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op21) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_op20) = 0x0a753500950fa306; ++ *((unsigned long *)&__m128i_result1) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_result0) = 0x0a753500a9fa0d06; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op00) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result0) = 0x4f4f4f4f4f4f4f4f; ++ __m128i_out = __lsx_vmaddwod_d_wu (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op21) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007f7f80807f7f80; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000020302030; ++ *((unsigned long *)&__m128i_op10) = 0x0000000020302030; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x3fffffffc0000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000006e17bfd8; ++ *((unsigned long *)&__m128i_op00) = 0x000000006e17bfd8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffff0100000001; ++ *((unsigned long *)&__m128i_op20) = 0xffffff0100000001; ++ *((unsigned long *)&__m128i_result1) = 0x000000006e17bfd8; ++ *((unsigned long *)&__m128i_result0) = 0x000000006e17bfd8; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op21) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op20) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x00010000fffffffc; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000008000e2e3; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000008000e2e3; ++ *((unsigned long *)&__m128i_op10) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080806362; ++ *((unsigned long *)&__m128i_result0) = 0x807f808000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffa; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8101010181010101; ++ *((unsigned long *)&__m128i_op10) = 0x8101010181010101; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op21) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000101010015; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffed00010001; ++ __m128i_out = __lsx_vmaddwev_q_du (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-3.c +new file mode 100644 +index 000000000..8a4c39502 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaddwod-3.c +@@ -0,0 +1,460 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00003fe00ffe3fe0; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000b5207f80; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000b5207f80; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe218ffffea10; ++ *((unsigned long *)&__m128i_op00) = 0xfffff208fffffa02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xfffff208fffffa02; ++ *((unsigned long *)&__m128i_result1) = 0xffffe218ffffea10; ++ *((unsigned long *)&__m128i_result0) = 0xfffff208fffffa02; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000bd3d00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000bd3d00000000; ++ *((unsigned long *)&__m128i_op21) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000bd3d00000000; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0032000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op20) = 0x2020202020207f7f; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000a0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op21) = 0x0000000120002000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001021; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op11) = 0x0002000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0002000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000014; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op21) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128i_op20) = 0xc3818bffe7b7a7b8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000467fe000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000003ff8; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000003ff8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000467fef81; ++ __m128i_out = __lsx_vmaddwod_h_bu_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fc0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x1e801ffc00000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff020000fff4; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x7fc0000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1e801ffc00000000; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3c600000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfe80000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfe80000000000001; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffffff03ffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00013fff; ++ *((unsigned long *)&__m128i_op11) = 0x000088500000f6a0; ++ *((unsigned long *)&__m128i_op10) = 0x0001fffd00000407; ++ *((unsigned long *)&__m128i_op21) = 0x0000442900007b4c; ++ *((unsigned long *)&__m128i_op20) = 0x0000e22b0000efa4; ++ *((unsigned long *)&__m128i_result1) = 0x00ffffff03ffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00013fff; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x14ccc6320176a4d2; ++ *((unsigned long *)&__m128i_op00) = 0x685670d37e80682a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x14ccc6320176a4d2; ++ *((unsigned long *)&__m128i_result0) = 0x685670d37e80682a; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xc0411fe800000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x601fbfbeffffffff; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffc105d1aa; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffbc19ecca; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff3efa; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff43e6; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffa7; ++ *((unsigned long *)&__m128i_op11) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128i_op10) = 0x00a975be00accf03; ++ *((unsigned long *)&__m128i_op21) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128i_op20) = 0x00a975be00accf03; ++ *((unsigned long *)&__m128i_result1) = 0x0000930400008a10; ++ *((unsigned long *)&__m128i_result0) = 0x00006f9100007337; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_w_hu_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op20) = 0x001000100010c410; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff02ff1bff02ff23; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffffff02fff4; ++ *((unsigned long *)&__m128i_op11) = 0xff02ff1bff02ff23; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffff02fff4; ++ *((unsigned long *)&__m128i_op21) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op20) = 0x1e801ffc7fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x7e44bde9b842ff23; ++ *((unsigned long *)&__m128i_result0) = 0x00011e80007edff8; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffeffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe0d56a9774f3ea31; ++ *((unsigned long *)&__m128i_op00) = 0xe0dd268932a5edf9; ++ *((unsigned long *)&__m128i_op11) = 0xe0d56a9774f3ea31; ++ *((unsigned long *)&__m128i_op10) = 0xe0dd268932a5edf9; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xd8248069ffe78077; ++ *((unsigned long *)&__m128i_result1) = 0xe0d56a9774f3ea31; ++ *((unsigned long *)&__m128i_result0) = 0xbddaa86803e33c2a; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0028280000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0028280000282800; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op21) = 0x7505853d654185f5; ++ *((unsigned long *)&__m128i_op20) = 0x01010000fefe0101; ++ *((unsigned long *)&__m128i_result1) = 0x0028280000000000; ++ *((unsigned long *)&__m128i_result0) = 0x012927ffff272800; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffff7f00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff007f0101017f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000020000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000183fffffe5; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000073; ++ *((unsigned long *)&__m128i_op20) = 0x000000000000002a; ++ *((unsigned long *)&__m128i_result1) = 0x00ffff7f00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff007f0101017f; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128i_op21) = 0x3f8000003f800001; ++ *((unsigned long *)&__m128i_op20) = 0x3f8000003f800001; ++ *((unsigned long *)&__m128i_result1) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result0) = 0x3f8000003f800000; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000095896a760000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x006f0efe258ca851; ++ *((unsigned long *)&__m128i_op21) = 0xffff7fc8ffff8000; ++ *((unsigned long *)&__m128i_op20) = 0xffff200000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000015516a768038; ++ *((unsigned long *)&__m128i_result0) = 0xffffff9ed2e1c000; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000120002000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op11) = 0x2000200000013fa0; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000013fa0; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000120002000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100013fa0; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_op00) = 0x0080006b00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x001b19b1c9c6da5a; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x001b19b1c9c6da5a; ++ *((unsigned long *)&__m128i_result1) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_result0) = 0x008003496dea0c61; ++ __m128i_out = __lsx_vmaddwod_d_wu_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op00) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op11) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op10) = 0x000001ff000001ff; ++ *((unsigned long *)&__m128i_op21) = 0xff80ffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x7ffffffeffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000002fe800000ff; ++ *((unsigned long *)&__m128i_result0) = 0x7ffffe0100000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff00000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfe80000000000001; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op20) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaddwev_q_du_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-addition-vsadd-ins.patch
Added
@@ -0,0 +1,715 @@ +From 243656b5b87a3125c2a885d11f022a79cca98b39 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 10:07:24 +0800 +Subject: PATCH 082/124 LoongArch: Add tests for SX vector addition vsadd + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vsadd-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsadd-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vsadd-1.c | 335 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vsadd-2.c | 345 ++++++++++++++++++ + 2 files changed, 680 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-1.c +new file mode 100644 +index 000000000..1bc27c983 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-1.c +@@ -0,0 +1,335 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfefefefefefefefe; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff3c992b2e; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff730f; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff3c992b2e; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff730f; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128i_result1) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_result0) = 0x000000002bfd9461; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001021; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001021; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001000; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x80808080806b000b; ++ __m128i_out = __lsx_vsadd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_op11) = 0x3c600000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x3c5fffffff7fffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffeff00feff; ++ __m128i_out = __lsx_vsadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vsadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vsadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x40f3fa0000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x40f3fa0000000000; ++ __m128i_out = __lsx_vsadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000008a0000008a; ++ *((unsigned long *)&__m128i_op00) = 0x0000008900000009; ++ *((unsigned long *)&__m128i_op11) = 0x63637687636316bb; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x6363771163631745; ++ *((unsigned long *)&__m128i_result0) = 0x636363ec6363636c; ++ __m128i_out = __lsx_vsadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vsadd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffefefe6a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c2bac2c2; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fefefe68; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c2bac2c2; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x027c027c000027c0; ++ *((unsigned long *)&__m128i_op11) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_op10) = 0x000fffefffefffef; ++ *((unsigned long *)&__m128i_result1) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_result0) = 0x028c026bfff027af; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0003000000010000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0007000000040000; ++ *((unsigned long *)&__m128i_result0) = 0x0003000000010000; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op11) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7f7fff003f800000; ++ *((unsigned long *)&__m128i_result0) = 0x7f7fff003f800000; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000820202020; ++ *((unsigned long *)&__m128i_op00) = 0x00fe01fc0005fff4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_op10) = 0x003dbe88077c78c1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000820205a44; ++ *((unsigned long *)&__m128i_result0) = 0x013bc084078278b5; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000140001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000140001; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x67eb85b0b2ebb001; ++ *((unsigned long *)&__m128i_result0) = 0xc8847ef6ed3f2000; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128i_op10) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff14eb54ab; ++ *((unsigned long *)&__m128i_result0) = 0x14ea6a002a406a00; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xce9035c49ffff570; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result0) = 0xce9035c49ffff574; ++ __m128i_out = __lsx_vsadd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000040d; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op00) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_result0) = 0x0000001300000013; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_result0) = 0x00000001000000ff; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000300000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result1) = 0x00000002fffffffb; ++ *((unsigned long *)&__m128i_result0) = 0x000000010000fffb; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vadd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-2.c +new file mode 100644 +index 000000000..67d189991 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsadd-2.c +@@ -0,0 +1,345 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_op10) = 0x203e16d116de012b; ++ *((unsigned long *)&__m128i_result1) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_result0) = 0x203e16d116de012b; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffebd06fffe820c; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7ffe7fff3506; ++ *((unsigned long *)&__m128i_op11) = 0xfffebd06fffe820c; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7ffe7fff3506; ++ *((unsigned long *)&__m128i_result1) = 0xffffff0cffffff18; ++ *((unsigned long *)&__m128i_result0) = 0xfefffefffeff6a0c; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffff60ca7104649; ++ *((unsigned long *)&__m128i_op00) = 0xfffff790a15db63d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xfffff60ca710464a; ++ *((unsigned long *)&__m128i_result0) = 0xfffff790a15db63e; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff46; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00fe000100cf005f; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op11) = 0x5f675e96e29a5a60; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x5fff5e97e2ff5abf; ++ *((unsigned long *)&__m128i_result0) = 0xfefffefffefffeff; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000100010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010058; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001001100110068; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_result1) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfeffffffffffffff; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128i_op00) = 0x00012c8a0000a58a; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffb81a6f70; ++ *((unsigned long *)&__m128i_op10) = 0x0000000d48eaa1a2; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffb81ae0bf; ++ *((unsigned long *)&__m128i_result0) = 0x00012c9748eaffff; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0177fff0fffffff0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000011ff8bc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsadd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000d0000000d; ++ *((unsigned long *)&__m128i_op11) = 0x8006000000040000; ++ *((unsigned long *)&__m128i_op10) = 0x8002000000000007; ++ *((unsigned long *)&__m128i_result1) = 0x8006000000040000; ++ *((unsigned long *)&__m128i_result0) = 0x8002000d00000014; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000014; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x1); ++ *((unsigned long *)&__m128i_op01) = 0x0000000600007fff; ++ *((unsigned long *)&__m128i_op00) = 0x00000008ffffa209; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000600007fff; ++ *((unsigned long *)&__m128i_result0) = 0x00000008ffffa209; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x636363633f3e47c1; ++ *((unsigned long *)&__m128i_op00) = 0x41f8e080f1ef4eaa; ++ *((unsigned long *)&__m128i_op11) = 0x00000807bf0a1f80; ++ *((unsigned long *)&__m128i_op10) = 0x00000800ecedee68; ++ *((unsigned long *)&__m128i_result1) = 0x63636b6afe486741; ++ *((unsigned long *)&__m128i_result0) = 0x41f8e880ffffffff; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128i_op00) = 0x00012c8a0000a58a; ++ *((unsigned long *)&__m128i_op11) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128i_op10) = 0x00012c8a0000a58a; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000e29e; ++ *((unsigned long *)&__m128i_result0) = 0x000259140000ffff; ++ __m128i_out = __lsx_vsadd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffeffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffeffffffff; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0c03e17edd781b11; ++ *((unsigned long *)&__m128i_op00) = 0x342caf9be55700b5; ++ *((unsigned long *)&__m128i_op11) = 0x00040003ff83ff84; ++ *((unsigned long *)&__m128i_op10) = 0x00040003ff4dffca; ++ *((unsigned long *)&__m128i_result1) = 0x0c07e181ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x3430af9effffffff; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffa8ff9f; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffffffabff99; ++ *((unsigned long *)&__m128i_op11) = 0x000100000002007d; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000020001; ++ *((unsigned long *)&__m128i_result1) = 0x00010000ffab001c; ++ *((unsigned long *)&__m128i_result0) = 0x0001ffffffadff9a; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_op10) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_result1) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_result0) = 0x0800080008000800; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x76f424887fffffff; ++ *((unsigned long *)&__m128i_op11) = 0xc110000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xc00d060000000000; ++ *((unsigned long *)&__m128i_result1) = 0xc110000000000001; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff7fffffff; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000002f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000029; ++ *((unsigned long *)&__m128i_op11) = 0xfbfbfb17fbfb38ea; ++ *((unsigned long *)&__m128i_op10) = 0xfbfb47fbfbfb0404; ++ *((unsigned long *)&__m128i_result1) = 0xfbfbfb17fbfb3919; ++ *((unsigned long *)&__m128i_result0) = 0xfbfb47fbfbfb042d; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808081; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x80808080ffffffff; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00123fff00120012; ++ *((unsigned long *)&__m128i_op00) = 0x0012001200120012; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000005003a; ++ *((unsigned long *)&__m128i_result1) = 0x00123fff00120012; ++ *((unsigned long *)&__m128i_result0) = 0x001200120017004c; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_op10) = 0xc5c534920000c4ed; ++ *((unsigned long *)&__m128i_result1) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_result0) = 0xc5c534920000c4ed; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000aa822a79308f6; ++ *((unsigned long *)&__m128i_op00) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op11) = 0x000aa822a79308f6; ++ *((unsigned long *)&__m128i_op10) = 0x03aa558e1d37b5a1; ++ *((unsigned long *)&__m128i_result1) = 0x00155044ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x03aa558e2584c86f; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x021b7d24c9678a35; ++ *((unsigned long *)&__m128i_op00) = 0x030298a6a1030a49; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x021b7d24c9678a35; ++ *((unsigned long *)&__m128i_result0) = 0x030298a6a1030a49; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007a8000000480; ++ *((unsigned long *)&__m128i_op00) = 0x00000485000004cc; ++ *((unsigned long *)&__m128i_op11) = 0x00007a8000000480; ++ *((unsigned long *)&__m128i_op10) = 0x00000485000004cc; ++ *((unsigned long *)&__m128i_result1) = 0x0000f50000000900; ++ *((unsigned long *)&__m128i_result0) = 0x0000090a00000998; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x004eff6200d2ff76; ++ *((unsigned long *)&__m128i_op10) = 0xff70002800be00a0; ++ *((unsigned long *)&__m128i_result1) = 0x004eff6200d2ff76; ++ *((unsigned long *)&__m128i_result0) = 0xff70002800be00a0; ++ __m128i_out = __lsx_vsadd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-floating-point-ari.patch
Added
@@ -0,0 +1,2928 @@ +From 4ccb21b6d2d23046c6a71c4540a1eb288609f041 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 11:25:20 +0800 +Subject: PATCH 093/124 LoongArch: Add tests for SX vector floating point + arithmetic instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vfadd_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfadd_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfclass_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfclass_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vflogb_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vflogb_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfmax_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfmax_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfmaxa_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfmaxa_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfsqrt_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfsqrt_s.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vfadd_d.c | 407 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vfadd_s.c | 470 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vfclass_d.c | 83 ++++ + .../loongarch/vector/lsx/lsx-vfclass_s.c | 74 +++ + .../loongarch/vector/lsx/lsx-vflogb_d.c | 76 +++ + .../loongarch/vector/lsx/lsx-vflogb_s.c | 185 +++++++ + .../loongarch/vector/lsx/lsx-vfmax_d.c | 200 ++++++++ + .../loongarch/vector/lsx/lsx-vfmax_s.c | 335 +++++++++++++ + .../loongarch/vector/lsx/lsx-vfmaxa_d.c | 155 ++++++ + .../loongarch/vector/lsx/lsx-vfmaxa_s.c | 230 +++++++++ + .../loongarch/vector/lsx/lsx-vfsqrt_d.c | 216 ++++++++ + .../loongarch/vector/lsx/lsx-vfsqrt_s.c | 372 ++++++++++++++ + 12 files changed, 2803 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_s.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_d.c +new file mode 100644 +index 000000000..7ffbd385e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_d.c +@@ -0,0 +1,407 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000fea8ff44; ++ *((unsigned long *)&__m128d_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m128d_op10) = 0x2020202020202020; ++ *((unsigned long *)&__m128d_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m128d_result0) = 0x2020202020202020; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128d_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x1000100010001000; ++ *((unsigned long *)&__m128d_result0) = 0x1000100010001000; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000000000000f; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x000000000000000f; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000010100fe0101; ++ *((unsigned long *)&__m128d_op00) = 0xffff0200ffff01ff; ++ *((unsigned long *)&__m128d_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x0001010100fe0100; ++ *((unsigned long *)&__m128d_result0) = 0xffff0200ffff01ff; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7fff0101ffffe000; ++ *((unsigned long *)&__m128d_op00) = 0x7fffffffa0204000; ++ *((unsigned long *)&__m128d_op11) = 0x7f370101ff04ffff; ++ *((unsigned long *)&__m128d_op10) = 0x7f3bffffa0226021; ++ *((unsigned long *)&__m128d_result1) = 0x7fff0101ffffe000; ++ *((unsigned long *)&__m128d_result0) = 0x7fffffffa0204000; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128d_op00) = 0x00012c8a0000a58a; ++ *((unsigned long *)&__m128d_op11) = 0xf654ad7447e59090; ++ *((unsigned long *)&__m128d_op10) = 0x27b1b106b8145f50; ++ *((unsigned long *)&__m128d_result1) = 0xf654ad7447e59090; ++ *((unsigned long *)&__m128d_result0) = 0x27b1b106b8145f50; ++ __m128d_out = __lsx_vfadd_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000001300000013; ++ *((unsigned long *)&__m128d_op10) = 0x0000001300000013; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000100000000000; ++ *((unsigned long *)&__m128d_op00) = 0x1000100000001000; ++ *((unsigned long *)&__m128d_op11) = 0x0000100000000000; ++ *((unsigned long *)&__m128d_op10) = 0x1000100000001000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0010001000100010; ++ *((unsigned long *)&__m128d_op00) = 0x0010001000100010; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000007000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x01533b5e7489ae24; ++ *((unsigned long *)&__m128d_op00) = 0xffffab7e71e33848; ++ *((unsigned long *)&__m128d_op11) = 0x01533b5e7489ae24; ++ *((unsigned long *)&__m128d_op10) = 0xffffab7e71e33848; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffab7e71e33848; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmul_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128d_op10) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128d_result1) = 0x800000ff000000ff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m128d_op10) = 0x00000000fff80000; ++ *((unsigned long *)&__m128d_result1) = 0x80000000fff8fff8; ++ *((unsigned long *)&__m128d_result0) = 0x80000000fff80000; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128d_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128d_op11) = 0xb55ccf30f52a6a68; ++ *((unsigned long *)&__m128d_op10) = 0x4e0018eceb82c53a; ++ *((unsigned long *)&__m128d_result1) = 0x355ccf30f52a6a68; ++ *((unsigned long *)&__m128d_result0) = 0xce0018eceb82c53a; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffff00006c82; ++ *((unsigned long *)&__m128d_op00) = 0x00009b140000917b; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffff00006c82; ++ *((unsigned long *)&__m128d_result0) = 0x00009b140000917b; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000100000020; ++ *((unsigned long *)&__m128d_op10) = 0x0000083b00000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xe93d0bd19ff0c170; ++ *((unsigned long *)&__m128d_op00) = 0x5237c1bac9eadf55; ++ *((unsigned long *)&__m128d_op11) = 0xe6d4572c8a5835bc; ++ *((unsigned long *)&__m128d_op10) = 0xe5017c2ac9ca9fd0; ++ *((unsigned long *)&__m128d_result1) = 0xe93d0bd19ff07013; ++ *((unsigned long *)&__m128d_result0) = 0x65017c2ac9ca9fd0; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xe93d0bd19ff07013; ++ *((unsigned long *)&__m128d_op00) = 0x65017c2ac9ca9fd0; ++ *((unsigned long *)&__m128d_op11) = 0x00008bf700017052; ++ *((unsigned long *)&__m128d_op10) = 0x0000f841000091aa; ++ *((unsigned long *)&__m128d_result1) = 0xe93d0bd19ff07013; ++ *((unsigned long *)&__m128d_result0) = 0x65017c2ac9ca9fd0; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000004000000002; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x5555410154551515; ++ *((unsigned long *)&__m128d_op10) = 0x0004455501500540; ++ *((unsigned long *)&__m128d_result1) = 0xd555410154551515; ++ *((unsigned long *)&__m128d_result0) = 0x8004455501500540; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000300037ff000ff; ++ *((unsigned long *)&__m128d_op00) = 0x0003000300a10003; ++ *((unsigned long *)&__m128d_op11) = 0x000000007ff000ff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0003000300000000; ++ *((unsigned long *)&__m128d_result0) = 0x0003000300a10003; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x56a09e662ab46b31; ++ *((unsigned long *)&__m128d_op10) = 0xb4b8122ef4054bb3; ++ *((unsigned long *)&__m128d_result1) = 0xd6a09e662ab46b31; ++ *((unsigned long *)&__m128d_result0) = 0x34b8122ef4054bb3; ++ __m128d_out = __lsx_vfsub_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7f4000007f040000; ++ *((unsigned long *)&__m128d_op00) = 0x7f0200007f020000; ++ *((unsigned long *)&__m128d_op11) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128d_op10) = 0xffffffff01018888; ++ *((unsigned long *)&__m128d_result1) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128d_result0) = 0xffffffff01018888; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128d_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000100007f01; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff8000000000000; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffefefffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000020; ++ *((unsigned long *)&__m128d_op10) = 0x0400000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffefefffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff8000000000000; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000ff801c9e; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000810000; ++ *((unsigned long *)&__m128d_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x40eff02383e383e4; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0001000000010000; ++ *((unsigned long *)&__m128d_op00) = 0x0000cd630000cd63; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffff00000000ffff; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x000aa822a79308f6; ++ *((unsigned long *)&__m128d_op10) = 0x03aa558e1d37b5a1; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128d_op00) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128d_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128d_op10) = 0xfffefffe011df03e; ++ *((unsigned long *)&__m128d_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128d_result0) = 0xfffffffefffffffe; ++ __m128d_out = __lsx_vfdiv_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_s.c +new file mode 100644 +index 000000000..388430278 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfadd_s.c +@@ -0,0 +1,470 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x05050505; ++ *((int *)&__m128_op02) = 0x05050505; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x05050000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x03574e38; ++ *((int *)&__m128_op10) = 0xe496cbc9; ++ *((int *)&__m128_result3) = 0x05050505; ++ *((int *)&__m128_result2) = 0x05050505; ++ *((int *)&__m128_result1) = 0x03574e38; ++ *((int *)&__m128_result0) = 0xe496cbc9; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000000f; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00077f88; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00077f97; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x000000ff; ++ *((int *)&__m128_op00) = 0x000000ff; ++ *((int *)&__m128_op13) = 0x370bdfec; ++ *((int *)&__m128_op12) = 0xffecffec; ++ *((int *)&__m128_op11) = 0x370bdfec; ++ *((int *)&__m128_op10) = 0xffecffec; ++ *((int *)&__m128_result3) = 0x370bdfec; ++ *((int *)&__m128_result2) = 0xffecffec; ++ *((int *)&__m128_result1) = 0x370bdfec; ++ *((int *)&__m128_result0) = 0xffecffec; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x0000ff00; ++ *((int *)&__m128_op10) = 0x00ff0000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffff0000; ++ *((int *)&__m128_op02) = 0xffff0000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x40088040; ++ *((int *)&__m128_op12) = 0x80040110; ++ *((int *)&__m128_op11) = 0x40408010; ++ *((int *)&__m128_op10) = 0x80200110; ++ *((int *)&__m128_result3) = 0xffff0000; ++ *((int *)&__m128_result2) = 0xffff0000; ++ *((int *)&__m128_result1) = 0x40408010; ++ *((int *)&__m128_result0) = 0x80200110; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xfffffffc; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xfffffffc; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xfffffffc; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xfffffffc; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x0000001b; ++ *((int *)&__m128_op02) = 0x0000001b; ++ *((int *)&__m128_op01) = 0x0000001b; ++ *((int *)&__m128_op00) = 0x0000001b; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x0000001b; ++ *((int *)&__m128_result2) = 0x0000001b; ++ *((int *)&__m128_result1) = 0x0000001b; ++ *((int *)&__m128_result0) = 0x0000001b; ++ __m128_out = __lsx_vfadd_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x56411278; ++ *((int *)&__m128_op02) = 0x43c0d41e; ++ *((int *)&__m128_op01) = 0x0124d8f6; ++ *((int *)&__m128_op00) = 0xa494006b; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x05010501; ++ *((int *)&__m128_op12) = 0x05010501; ++ *((int *)&__m128_op11) = 0x05010501; ++ *((int *)&__m128_op10) = 0x0501050c; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x21f32eaf; ++ *((int *)&__m128_op02) = 0x5b7a02c8; ++ *((int *)&__m128_op01) = 0x407c2ca3; ++ *((int *)&__m128_op00) = 0x2cbd0357; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00010400; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xfffe0001; ++ *((int *)&__m128_op02) = 0xfffe0001; ++ *((int *)&__m128_op01) = 0xfffe0001; ++ *((int *)&__m128_op00) = 0xfffe0001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0xfffe0001; ++ *((int *)&__m128_result2) = 0xfffe0001; ++ *((int *)&__m128_result1) = 0xfffe0001; ++ *((int *)&__m128_result0) = 0xfffe0001; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00002ebf; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x01000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00081f1f; ++ *((int *)&__m128_op02) = 0x1f1f1f1f; ++ *((int *)&__m128_op01) = 0x1f1f1f1f; ++ *((int *)&__m128_op00) = 0x1f1f1f1f; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x021b7d24; ++ *((int *)&__m128_op02) = 0x49678a35; ++ *((int *)&__m128_op01) = 0x030298a6; ++ *((int *)&__m128_op00) = 0x21030a49; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000002; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xf6548a17; ++ *((int *)&__m128_op02) = 0x47e59090; ++ *((int *)&__m128_op01) = 0x27b169bb; ++ *((int *)&__m128_op00) = 0xb8145f50; ++ *((int *)&__m128_op13) = 0x004eff62; ++ *((int *)&__m128_op12) = 0x00d2ff76; ++ *((int *)&__m128_op11) = 0xff700028; ++ *((int *)&__m128_op10) = 0x00be00a0; ++ *((int *)&__m128_result3) = 0xb7032c34; ++ *((int *)&__m128_result2) = 0x093d35ab; ++ *((int *)&__m128_result1) = 0xe7a6533b; ++ *((int *)&__m128_result0) = 0x800001b8; ++ __m128_out = __lsx_vfmul_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfsub_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x7fff0101; ++ *((int *)&__m128_op02) = 0x81010102; ++ *((int *)&__m128_op01) = 0x7fffffff; ++ *((int *)&__m128_op00) = 0x81010102; ++ *((int *)&__m128_op13) = 0x00000fff; ++ *((int *)&__m128_op12) = 0xffffe000; ++ *((int *)&__m128_op11) = 0x00001020; ++ *((int *)&__m128_op10) = 0x20204000; ++ *((int *)&__m128_result3) = 0x7fff0101; ++ *((int *)&__m128_result2) = 0xffffe000; ++ *((int *)&__m128_result1) = 0x7fffffff; ++ *((int *)&__m128_result0) = 0xa0204000; ++ __m128_out = __lsx_vfsub_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000fff; ++ *((int *)&__m128_op12) = 0xffffe000; ++ *((int *)&__m128_op11) = 0x00001020; ++ *((int *)&__m128_op10) = 0x20204000; ++ *((int *)&__m128_result3) = 0x80000fff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0x80001020; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfsub_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfsub_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x54feed87; ++ *((int *)&__m128_op02) = 0xbc3f2be1; ++ *((int *)&__m128_op01) = 0x8064d8f6; ++ *((int *)&__m128_op00) = 0xa494afcb; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xff800000; ++ __m128_out = __lsx_vfdiv_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xd8248069; ++ *((int *)&__m128_op00) = 0x7f678077; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xd8248069; ++ *((int *)&__m128_op10) = 0x7f678077; ++ *((int *)&__m128_result3) = 0x7fc00000; ++ *((int *)&__m128_result2) = 0x7fc00000; ++ *((int *)&__m128_result1) = 0x3f800000; ++ *((int *)&__m128_result0) = 0x3f800000; ++ __m128_out = __lsx_vfdiv_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7fc00000; ++ *((int *)&__m128_result2) = 0x7fc00000; ++ *((int *)&__m128_result1) = 0x7fc00000; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vfdiv_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00070000; ++ *((int *)&__m128_op02) = 0x00040000; ++ *((int *)&__m128_op01) = 0x00030000; ++ *((int *)&__m128_op00) = 0x00010000; ++ *((int *)&__m128_op13) = 0x00070000; ++ *((int *)&__m128_op12) = 0x00040000; ++ *((int *)&__m128_op11) = 0x00030000; ++ *((int *)&__m128_op10) = 0x00010000; ++ *((int *)&__m128_result3) = 0x3f800000; ++ *((int *)&__m128_result2) = 0x3f800000; ++ *((int *)&__m128_result1) = 0x3f800000; ++ *((int *)&__m128_result0) = 0x3f800000; ++ __m128_out = __lsx_vfdiv_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00010001; ++ *((int *)&__m128_op12) = 0x0001007c; ++ *((int *)&__m128_op11) = 0x00010001; ++ *((int *)&__m128_op10) = 0x00010001; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfdiv_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00001fff; ++ *((int *)&__m128_op02) = 0x00001fff; ++ *((int *)&__m128_op01) = 0x00000003; ++ *((int *)&__m128_op00) = 0xfffffffc; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0xfffffffc; ++ __m128_out = __lsx_vfdiv_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7fc00000; ++ *((int *)&__m128_result2) = 0x7fc00000; ++ *((int *)&__m128_result1) = 0x7fc00000; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vfdiv_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_d.c +new file mode 100644 +index 000000000..9706d7adc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_d.c +@@ -0,0 +1,83 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128d_op00) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000002; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128d_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000008; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x14ccc6320176a4d2; ++ *((unsigned long *)&__m128d_op00) = 0x685670d37e80682a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000080; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vfclass_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_s.c +new file mode 100644 +index 000000000..7166f954b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfclass_s.c +@@ -0,0 +1,74 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x7fff8000; ++ *((int *)&__m128_op01) = 0x00010081; ++ *((int *)&__m128_op00) = 0x00000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000020000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000100; ++ __m128i_out = __lsx_vfclass_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfe02fe02; ++ *((int *)&__m128_op02) = 0xfe02fe02; ++ *((int *)&__m128_op01) = 0xfe02fe02; ++ *((int *)&__m128_op00) = 0xfe02fe02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000800000008; ++ __m128i_out = __lsx_vfclass_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0000000c; ++ *((int *)&__m128_op02) = 0x7fff000c; ++ *((int *)&__m128_op01) = 0x10001000; ++ *((int *)&__m128_op00) = 0x10001000; ++ *((unsigned long *)&__m128i_result1) = 0x0000010000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000008000000080; ++ __m128i_out = __lsx_vfclass_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000020000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000020000000200; ++ __m128i_out = __lsx_vfclass_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000020000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000020000000200; ++ __m128i_out = __lsx_vfclass_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0c0b0a09; ++ *((int *)&__m128_op02) = 0x0b0a0908; ++ *((int *)&__m128_op01) = 0x0a090807; ++ *((int *)&__m128_op00) = 0x09080706; ++ *((unsigned long *)&__m128i_result1) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000008000000080; ++ __m128i_out = __lsx_vfclass_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_d.c +new file mode 100644 +index 000000000..cc36bf136 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_d.c +@@ -0,0 +1,76 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xc090c40000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m128d_op00) = 0x0000001000000048; ++ *((unsigned long *)&__m128d_result1) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m128d_result0) = 0xc090380000000000; ++ __m128d_out = __lsx_vflogb_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_s.c +new file mode 100644 +index 000000000..624589620 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vflogb_s.c +@@ -0,0 +1,185 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00003004; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xc3080000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xff800000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x01010101; ++ *((int *)&__m128_op02) = 0x01010101; ++ *((int *)&__m128_op01) = 0x01010101; ++ *((int *)&__m128_op00) = 0x01010101; ++ *((int *)&__m128_result3) = 0xc2fa0000; ++ *((int *)&__m128_result2) = 0xc2fa0000; ++ *((int *)&__m128_result1) = 0xc2fa0000; ++ *((int *)&__m128_result0) = 0xc2fa0000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x01ff01ff; ++ *((int *)&__m128_op02) = 0x01ff01ff; ++ *((int *)&__m128_op01) = 0x01ff01ff; ++ *((int *)&__m128_op00) = 0x01ff01ff; ++ *((int *)&__m128_result3) = 0xc2f80000; ++ *((int *)&__m128_result2) = 0xc2f80000; ++ *((int *)&__m128_result1) = 0xc2f80000; ++ *((int *)&__m128_result0) = 0xc2f80000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xd46cdc13; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00fe00fe; ++ *((int *)&__m128_op02) = 0x000200fe; ++ *((int *)&__m128_op01) = 0x00fe00fe; ++ *((int *)&__m128_op00) = 0x000200fe; ++ *((int *)&__m128_result3) = 0xc2fc0000; ++ *((int *)&__m128_result2) = 0xc3040000; ++ *((int *)&__m128_result1) = 0xc2fc0000; ++ *((int *)&__m128_result0) = 0xc3040000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x01010101; ++ *((int *)&__m128_op00) = 0x00000100; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xc2fa0000; ++ *((int *)&__m128_result0) = 0xc30d0000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000014; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000014; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xc3110000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xc3110000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x4e3e1337; ++ *((int *)&__m128_op00) = 0x38bb47d2; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0x41e80000; ++ *((int *)&__m128_result0) = 0xc1600000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xff800000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xff800000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xff800000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00003ff8; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0xc3080000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xf1f181a2; ++ *((int *)&__m128_op02) = 0xf1f1f1b0; ++ *((int *)&__m128_op01) = 0xf1f1f1f1; ++ *((int *)&__m128_op00) = 0xf180f1f1; ++ *((int *)&__m128_result3) = 0x7fc00000; ++ *((int *)&__m128_result2) = 0x7fc00000; ++ *((int *)&__m128_result1) = 0x7fc00000; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vflogb_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_d.c +new file mode 100644 +index 000000000..442473fb4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_d.c +@@ -0,0 +1,200 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128d_op11) = 0x0400040004000400; ++ *((unsigned long *)&__m128d_op10) = 0x0400040004000400; ++ *((unsigned long *)&__m128d_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128d_result0) = 0x0400040004000400; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m128d_op00) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m128d_result0) = 0x01ff01ff01ff01ff; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128d_op00) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128d_result0) = 0xfffcfffcfffcfffc; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x000000000000ffff; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128d_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op10) = 0xfdfef9ff0efff900; ++ *((unsigned long *)&__m128d_result1) = 0x6363636363636363; ++ *((unsigned long *)&__m128d_result0) = 0x6363636363636363; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128d_op00) = 0xa352bfac9269e0aa; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x98147a504d145000; ++ *((unsigned long *)&__m128d_op00) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128d_op11) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128d_op10) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128d_result1) = 0x98147a504d145000; ++ *((unsigned long *)&__m128d_result0) = 0x377b810912c0e000; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128d_op00) = 0xc3818bffe7b7a7b8; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x17c64aaef639f093; ++ *((unsigned long *)&__m128d_op00) = 0xdb8f439722ec502d; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x17c64aaef639f093; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x10f881a20ffd02b0; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ff800000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x10f881a20ffd02b0; ++ *((unsigned long *)&__m128d_result0) = 0x00000000ff800000; ++ __m128d_out = __lsx_vfmax_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128d_op00) = 0x0000c000ffffc000; ++ *((unsigned long *)&__m128d_op11) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128d_op10) = 0x0000958affff995d; ++ *((unsigned long *)&__m128d_result1) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128d_result0) = 0x0000958affff995d; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x1748c4f9ed1a5870; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmin_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_s.c +new file mode 100644 +index 000000000..876588827 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmax_s.c +@@ -0,0 +1,335 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x0000ffff; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x0000ffff; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xc2409eda; ++ *((int *)&__m128_op12) = 0xb019323f; ++ *((int *)&__m128_op11) = 0x460f3b39; ++ *((int *)&__m128_op10) = 0x3ef4be3a; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x460f3b39; ++ *((int *)&__m128_result0) = 0x3ef4be3a; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000001; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000001; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xfefd7f7f; ++ *((int *)&__m128_op12) = 0x7f7f7f7e; ++ *((int *)&__m128_op11) = 0xdffdbffe; ++ *((int *)&__m128_op10) = 0xba6f5543; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x7f7f7f7e; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xff84fff4; ++ *((int *)&__m128_op02) = 0xff84fff4; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffff0; ++ *((int *)&__m128_op13) = 0xff84fff4; ++ *((int *)&__m128_op12) = 0xff84fff4; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xfffffff0; ++ *((int *)&__m128_result3) = 0xffc4fff4; ++ *((int *)&__m128_result2) = 0xffc4fff4; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xfffffff0; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00007fff; ++ *((int *)&__m128_op12) = 0x00007fff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00007fff; ++ *((int *)&__m128_result2) = 0x00007fff; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000001; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x01010001; ++ *((int *)&__m128_op00) = 0x01010001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00020000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00020000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00020000; ++ *((int *)&__m128_result1) = 0x01010001; ++ *((int *)&__m128_result0) = 0x01010001; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000020; ++ *((int *)&__m128_op12) = 0x00000020; ++ *((int *)&__m128_op11) = 0x0000001f; ++ *((int *)&__m128_op10) = 0x0000001f; ++ *((int *)&__m128_result3) = 0x00000020; ++ *((int *)&__m128_result2) = 0x00000020; ++ *((int *)&__m128_result1) = 0x0000001f; ++ *((int *)&__m128_result0) = 0x0000001f; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xf3040705; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xf3040705; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0xf3040705; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000004; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000004; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000004; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000004; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000004; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000004; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmax_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x0000ffff; ++ *((int *)&__m128_op02) = 0x0000ffff; ++ *((int *)&__m128_op01) = 0x0000ffff; ++ *((int *)&__m128_op00) = 0x0000fffe; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmin_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffe5; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffe5; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmin_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmin_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x13121110; ++ *((int *)&__m128_op02) = 0x1211100f; ++ *((int *)&__m128_op01) = 0x11100f0e; ++ *((int *)&__m128_op00) = 0x100f0e0d; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmin_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffff3; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000008; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000088; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000008; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000088; ++ __m128_out = __lsx_vfmin_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x52525252; ++ *((int *)&__m128_op02) = 0xadadadad; ++ *((int *)&__m128_op01) = 0x52525252; ++ *((int *)&__m128_op00) = 0xadadadad; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0xadadadad; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0xadadadad; ++ __m128_out = __lsx_vfmin_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000ffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x0000ffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x0000ffff; ++ __m128_out = __lsx_vfmin_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_d.c +new file mode 100644 +index 000000000..c2766d5c6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_d.c +@@ -0,0 +1,155 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000800000000000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x01203f1e3d1c3b1a; ++ *((unsigned long *)&__m128d_op00) = 0x3918371635143312; ++ *((unsigned long *)&__m128d_op11) = 0x00000af555555555; ++ *((unsigned long *)&__m128d_op10) = 0x00000af555555555; ++ *((unsigned long *)&__m128d_result1) = 0x01203f1e3d1c3b1a; ++ *((unsigned long *)&__m128d_result0) = 0x3918371635143312; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000010000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000010000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000010000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000010000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000010000000000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x10f8000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xfff8ffa2fffdffb0; ++ *((unsigned long *)&__m128d_op10) = 0x00000000ff800000; ++ *((unsigned long *)&__m128d_result1) = 0x10f8000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x00000000ff800000; ++ __m128d_out = __lsx_vfmaxa_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000200000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x0000000200000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmina_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000080000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x80000000fff6fc00; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000080000000; ++ __m128d_out = __lsx_vfmina_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000080000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmina_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000158; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmina_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xfffe0004fffe0004; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmina_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128d_op00) = 0xff800000ff800000; ++ *((unsigned long *)&__m128d_op11) = 0x002a001a001a000b; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x002a001a001a000b; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmina_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_s.c +new file mode 100644 +index 000000000..5fcdedd3f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmaxa_s.c +@@ -0,0 +1,230 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmaxa_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xf436f3f5; ++ *((int *)&__m128_op00) = 0x2f4ef4a8; ++ *((int *)&__m128_op13) = 0xff800000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xff800000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xff800000; ++ *((int *)&__m128_result0) = 0x2f4ef4a8; ++ __m128_out = __lsx_vfmaxa_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000800; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000800; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000800; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000800; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmaxa_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xc0c0c000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00800080; ++ *((int *)&__m128_op12) = 0x00800080; ++ *((int *)&__m128_op11) = 0x0080006b; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00800080; ++ *((int *)&__m128_result2) = 0xc0c0c000; ++ *((int *)&__m128_result1) = 0x0080006b; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmaxa_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmaxa_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x80000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x80000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmaxa_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmaxa_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmina_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmina_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmina_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xff01ff01; ++ *((int *)&__m128_op12) = 0x0000ff7d; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x0000fffc; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmina_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xdfa6e0c6; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xd46cdc13; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmina_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x01010101; ++ *((int *)&__m128_op02) = 0x01010101; ++ *((int *)&__m128_op01) = 0x010101fe; ++ *((int *)&__m128_op00) = 0x0101fe87; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmina_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffff0000; ++ *((int *)&__m128_op12) = 0xffff0000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmina_s (__m128_op0, __m128_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_d.c +new file mode 100644 +index 000000000..8a35dfe24 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_d.c +@@ -0,0 +1,216 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffa486c90f; ++ *((unsigned long *)&__m128d_op00) = 0x0000000058bcc201; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffa486c90f; ++ *((unsigned long *)&__m128d_result0) = 0x1f52d710bf295626; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffff01ff01; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000be00be; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x1f1b917c9f3d5e05; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000001400000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128d_result0) = 0x1f81e3779b97f4a8; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128d_op00) = 0xff800000ff800000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff8000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x001effae001effae; ++ *((unsigned long *)&__m128d_op00) = 0x001effae001effae; ++ *((unsigned long *)&__m128d_result1) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128d_result0) = 0x2006454690d3de87; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128d_op00) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128d_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff8000000000000; ++ __m128d_out = __lsx_vfsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xff800000ff800000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0x7ff8000000000000; ++ __m128d_out = __lsx_vfrsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0001ffff00000000; ++ *((unsigned long *)&__m128d_op00) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128d_result1) = 0x5ff6a0a40ea8f47c; ++ *((unsigned long *)&__m128d_result0) = 0x5ff6a0a40e9da42a; ++ __m128d_out = __lsx_vfrsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000000f; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x61608654a2d4f6da; ++ __m128d_out = __lsx_vfrsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00fe000100cf005f; ++ *((unsigned long *)&__m128d_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128d_result1) = 0x5f675e96e29a5a60; ++ *((unsigned long *)&__m128d_result0) = 0x7fff7fff7fff7fff; ++ __m128d_out = __lsx_vfrsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrsqrt_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0x7ff8000000000000; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00003f8000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00003f8000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000fffa0000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000fffa0000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128d_op00) = 0xe593c8c4e593c8c4; ++ *((unsigned long *)&__m128d_result1) = 0x805ffffe01001fe0; ++ *((unsigned long *)&__m128d_result0) = 0x9a49e11102834d70; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128d_op00) = 0x5252dcdcdcdcdcdc; ++ *((unsigned long *)&__m128d_result1) = 0x2d8bf1f8fc7e3f20; ++ *((unsigned long *)&__m128d_result0) = 0x2d8b24b936d1b24d; ++ __m128d_out = __lsx_vfrecip_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_s.c +new file mode 100644 +index 000000000..ffd80540b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfsqrt_s.c +@@ -0,0 +1,372 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0xfe07e5fe; ++ *((int *)&__m128_op02) = 0xfefdddfe; ++ *((int *)&__m128_op01) = 0x00020100; ++ *((int *)&__m128_op00) = 0xfedd0c00; ++ *((int *)&__m128_result3) = 0x7fc00000; ++ *((int *)&__m128_result2) = 0x7fc00000; ++ *((int *)&__m128_result1) = 0x1e801ffc; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xff00ff00; ++ *((int *)&__m128_op02) = 0xff00ff00; ++ *((int *)&__m128_op01) = 0xff00ff00; ++ *((int *)&__m128_op00) = 0xff00ff00; ++ *((int *)&__m128_result3) = 0x7fc00000; ++ *((int *)&__m128_result2) = 0x7fc00000; ++ *((int *)&__m128_result1) = 0x7fc00000; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x8c7fc73a; ++ *((int *)&__m128_op02) = 0x137e54af; ++ *((int *)&__m128_op01) = 0xbc84cf6f; ++ *((int *)&__m128_op00) = 0x76208329; ++ *((int *)&__m128_result3) = 0x7fc00000; ++ *((int *)&__m128_result2) = 0x297f29fe; ++ *((int *)&__m128_result1) = 0x7fc00000; ++ *((int *)&__m128_result0) = 0x5acab5a5; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffff9727; ++ *((int *)&__m128_op02) = 0xffff9727; ++ *((int *)&__m128_op01) = 0xfffffe79; ++ *((int *)&__m128_op00) = 0xffffba5f; ++ *((int *)&__m128_result3) = 0xffff9727; ++ *((int *)&__m128_result2) = 0xffff9727; ++ *((int *)&__m128_result1) = 0xfffffe79; ++ *((int *)&__m128_result0) = 0xffffba5f; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xfff8fff8; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xfff80000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0xfff8fff8; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0xfff80000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x1f1b917c; ++ *((int *)&__m128_op00) = 0x9f3d5e05; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x4fa432d6; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x12835580; ++ *((int *)&__m128_op00) = 0xb880eb98; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0x55fcbad1; ++ *((int *)&__m128_result0) = 0x7fc00000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x06070607; ++ *((int *)&__m128_op02) = 0x00000807; ++ *((int *)&__m128_op01) = 0x0707f8f8; ++ *((int *)&__m128_op00) = 0x03e8157e; ++ *((int *)&__m128_result3) = 0x5c303f97; ++ *((int *)&__m128_result2) = 0x61ff9049; ++ *((int *)&__m128_result1) = 0x5bafa1dd; ++ *((int *)&__m128_result0) = 0x5d3e1e1d; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xfff7fffe; ++ *((int *)&__m128_op02) = 0xfffa01ff; ++ *((int *)&__m128_op01) = 0xfffbfffe; ++ *((int *)&__m128_op00) = 0xfffe01ff; ++ *((int *)&__m128_result3) = 0xfff7fffe; ++ *((int *)&__m128_result2) = 0xfffa01ff; ++ *((int *)&__m128_result1) = 0xfffbfffe; ++ *((int *)&__m128_result0) = 0xfffe01ff; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x45000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x44000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x3cb504f3; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x3d3504f3; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00020001; ++ *((int *)&__m128_op00) = 0x00020002; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x607fffc0; ++ *((int *)&__m128_result0) = 0x607fff80; ++ __m128_out = __lsx_vfrsqrt_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000002; ++ *((int *)&__m128_op02) = 0x00000002; ++ *((int *)&__m128_op01) = 0x00000003; ++ *((int *)&__m128_op00) = 0x00000003; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xf6e91c00; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x51cfd7c0; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x880c91b8; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x2d1da85b; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xfffffffa; ++ *((int *)&__m128_op02) = 0xfffffffa; ++ *((int *)&__m128_op01) = 0xfffffffa; ++ *((int *)&__m128_op00) = 0xfffffffa; ++ *((int *)&__m128_result3) = 0xfffffffa; ++ *((int *)&__m128_result2) = 0xfffffffa; ++ *((int *)&__m128_result1) = 0xfffffffa; ++ *((int *)&__m128_result0) = 0xfffffffa; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffff0001; ++ *((int *)&__m128_op02) = 0xffff0001; ++ *((int *)&__m128_op01) = 0xffff0001; ++ *((int *)&__m128_op00) = 0xffff0001; ++ *((int *)&__m128_result3) = 0xffff0001; ++ *((int *)&__m128_result2) = 0xffff0001; ++ *((int *)&__m128_result1) = 0xffff0001; ++ *((int *)&__m128_result0) = 0xffff0001; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x0a000000; ++ *((int *)&__m128_op02) = 0x0a000000; ++ *((int *)&__m128_op01) = 0x0a000000; ++ *((int *)&__m128_op00) = 0x0a000000; ++ *((int *)&__m128_result3) = 0x75000000; ++ *((int *)&__m128_result2) = 0x75000000; ++ *((int *)&__m128_result1) = 0x75000000; ++ *((int *)&__m128_result0) = 0x75000000; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfrecip_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-floating-point-ins.patch
Added
@@ -0,0 +1,4316 @@ +From f9098b58fe79ba960e41b7ec6a05ba2ea18ca02e Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 09:42:39 +0800 +Subject: PATCH 079/124 LoongArch: Add tests for SX vector floating-point + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vfcvt-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcvt-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vffint-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vffint-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vffint-3.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfrint_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfrint_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vftint-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vftint-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vftint-3.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vftint-4.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vfcvt-1.c | 398 +++++++ + .../loongarch/vector/lsx/lsx-vfcvt-2.c | 278 +++++ + .../loongarch/vector/lsx/lsx-vffint-1.c | 161 +++ + .../loongarch/vector/lsx/lsx-vffint-2.c | 264 +++++ + .../loongarch/vector/lsx/lsx-vffint-3.c | 102 ++ + .../loongarch/vector/lsx/lsx-vfrint_d.c | 230 ++++ + .../loongarch/vector/lsx/lsx-vfrint_s.c | 350 ++++++ + .../loongarch/vector/lsx/lsx-vftint-1.c | 349 ++++++ + .../loongarch/vector/lsx/lsx-vftint-2.c | 695 +++++++++++ + .../loongarch/vector/lsx/lsx-vftint-3.c | 1028 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vftint-4.c | 345 ++++++ + 11 files changed, 4200 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-4.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-1.c +new file mode 100644 +index 000000000..d4a86e262 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-1.c +@@ -0,0 +1,398 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00e0000000e00000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002a55005501; ++ *((unsigned long *)&__m128i_op00) = 0x0000002a55000001; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x36280000; ++ *((int *)&__m128_result1) = 0x42a00000; ++ *((int *)&__m128_result0) = 0x42a02000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xf436f3f5; ++ *((int *)&__m128_op00) = 0x2f4ef4a8; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffcfb799f1; ++ *((unsigned long *)&__m128i_op00) = 0x0282800002828282; ++ *((int *)&__m128_result3) = 0xffffe000; ++ *((int *)&__m128_result2) = 0xffffe000; ++ *((int *)&__m128_result1) = 0xc1f6e000; ++ *((int *)&__m128_result0) = 0xbb3e2000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000040004000100; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x36de0000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x3be14000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x41dfffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x403be000; ++ *((int *)&__m128_result2) = 0xffffe000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x63637687; ++ *((int *)&__m128_op02) = 0x636316bb; ++ *((int *)&__m128_op01) = 0x63636363; ++ *((int *)&__m128_op00) = 0x63636363; ++ *((unsigned long *)&__m128d_result1) = 0x446c6ed0e0000000; ++ *((unsigned long *)&__m128d_result0) = 0x446c62d760000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x000000ff; ++ *((int *)&__m128_op02) = 0x000000ff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x371fe00000000000; ++ *((unsigned long *)&__m128d_result0) = 0x371fe00000000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff7fff7ef; ++ *((unsigned long *)&__m128i_op00) = 0x80808080ffffffff; ++ *((int *)&__m128_result3) = 0xffffe000; ++ *((int *)&__m128_result2) = 0xffffe000; ++ *((int *)&__m128_result1) = 0xc6ffe000; ++ *((int *)&__m128_result0) = 0xc6fde000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffe0000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffe1ffc100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000400000; ++ *((int *)&__m128_result3) = 0xfffc2000; ++ *((int *)&__m128_result2) = 0xfff82000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x0000b3a6; ++ *((int *)&__m128_op02) = 0x000067da; ++ *((int *)&__m128_op01) = 0x00004e42; ++ *((int *)&__m128_op00) = 0x0000c26a; ++ *((unsigned long *)&__m128d_result1) = 0x379674c000000000; ++ *((unsigned long *)&__m128d_result0) = 0x3789f68000000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xffff0000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffe0000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001001001000080; ++ *((unsigned long *)&__m128i_op00) = 0x4195d926d8018000; ++ *((int *)&__m128_result3) = 0x33800000; ++ *((int *)&__m128_result2) = 0x35800000; ++ *((int *)&__m128_result1) = 0x37800000; ++ *((int *)&__m128_result0) = 0x37000000; ++ __m128_out = __lsx_vfcvth_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvth_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((int *)&__m128_result3) = 0xffffe000; ++ *((int *)&__m128_result2) = 0xffffe000; ++ *((int *)&__m128_result1) = 0xffffe000; ++ *((int *)&__m128_result0) = 0xffffe000; ++ __m128_out = __lsx_vfcvtl_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op00) = 0x000a000a000a000a; ++ *((int *)&__m128_result3) = 0x35200000; ++ *((int *)&__m128_result2) = 0x35200000; ++ *((int *)&__m128_result1) = 0x35200000; ++ *((int *)&__m128_result0) = 0x35200000; ++ __m128_out = __lsx_vfcvtl_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x00000100; ++ *((int *)&__m128_op02) = 0x0f00fe00; ++ *((int *)&__m128_op01) = 0x0000017f; ++ *((int *)&__m128_op00) = 0xff00fe7f; ++ *((unsigned long *)&__m128d_result1) = 0x3727f00000000000; ++ *((unsigned long *)&__m128d_result0) = 0xc7e01fcfe0000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000020; ++ *((int *)&__m128_op00) = 0x00000020; ++ *((unsigned long *)&__m128d_result1) = 0x36f0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x36f0000000000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xbd994889; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0a092444; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x3941248880000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x62cbf96e4acfaf40; ++ *((unsigned long *)&__m128i_op00) = 0xf0bc9a5278285a4a; ++ *((int *)&__m128_result3) = 0xc6178000; ++ *((int *)&__m128_result2) = 0xbb4a4000; ++ *((int *)&__m128_result1) = 0x47050000; ++ *((int *)&__m128_result0) = 0x43494000; ++ __m128_out = __lsx_vfcvtl_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00040004; ++ *((int *)&__m128_op02) = 0x00040004; ++ *((int *)&__m128_op01) = 0x00040004; ++ *((int *)&__m128_op00) = 0x00040004; ++ *((unsigned long *)&__m128d_result1) = 0x37c0001000000000; ++ *((unsigned long *)&__m128d_result0) = 0x37c0001000000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff00ff00ff00; ++ *((int *)&__m128_result3) = 0xffe00000; ++ *((int *)&__m128_result2) = 0xffe00000; ++ *((int *)&__m128_result1) = 0xffe00000; ++ *((int *)&__m128_result0) = 0xffe00000; ++ __m128_out = __lsx_vfcvtl_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvtl_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvtl_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xffffe000; ++ *((int *)&__m128_result0) = 0xffffe000; ++ __m128_out = __lsx_vfcvtl_s_h (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x007f7f7f; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x380fdfdfc0000000; ++ __m128d_out = __lsx_vfcvtl_d_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-2.c +new file mode 100644 +index 000000000..e8f4f12b9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcvt-2.c +@@ -0,0 +1,278 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x004200a0; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x004200a0; ++ *((int *)&__m128_op00) = 0x00200001; ++ *((int *)&__m128_op13) = 0x004200a0; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x004200a0; ++ *((int *)&__m128_op10) = 0x00200000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00010001; ++ *((int *)&__m128_op12) = 0x0001007c; ++ *((int *)&__m128_op11) = 0x00010001; ++ *((int *)&__m128_op10) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x80808080; ++ *((int *)&__m128_op12) = 0x80808080; ++ *((int *)&__m128_op11) = 0x80808080; ++ *((int *)&__m128_op10) = 0x80808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000800080008000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xfffffffc; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffffc; ++ *((int *)&__m128_op13) = 0x00000001; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000103; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcvt_h_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000049000000c0; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ffffff29; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000100000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x7ff0000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000002c002400; ++ *((unsigned long *)&__m128d_op11) = 0x7ef400ad21fc7081; ++ *((unsigned long *)&__m128d_op10) = 0x28bf0351ec69b5f2; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000dc300003ffb; ++ *((unsigned long *)&__m128d_op00) = 0x00000dc300003ffb; ++ *((unsigned long *)&__m128d_op11) = 0x0000ffff3fbfffff; ++ *((unsigned long *)&__m128d_op10) = 0x7fffffff7fffffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x7ffffffb; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xbba0c07b51230d5c; ++ *((unsigned long *)&__m128d_op00) = 0xa15f3f9e8763c2b9; ++ *((unsigned long *)&__m128d_op11) = 0xbba0c07b51230d5c; ++ *((unsigned long *)&__m128d_op10) = 0xa15f3f9e8763c2b9; ++ *((int *)&__m128_result3) = 0x9d0603db; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x9d0603db; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128d_op11) = 0x8101010181010101; ++ *((unsigned long *)&__m128d_op10) = 0x8101010181010101; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffc00000ff800000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xfffdfffe80008000; ++ *((unsigned long *)&__m128d_op11) = 0x000000ff00000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0xffeffff4; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000090; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000090; ++ *((unsigned long *)&__m128d_op11) = 0x004eff6200d2ff76; ++ *((unsigned long *)&__m128d_op10) = 0xff70002800be00a0; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0xff800000; ++ __m128_out = __lsx_vfcvt_s_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-1.c +new file mode 100644 +index 000000000..85db95762 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-1.c +@@ -0,0 +1,161 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m128d_result0) = 0xbff0000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_op00) = 0x003dbe88077c78c1; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x40cd120000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x4050000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0086000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0082000000000007; ++ *((unsigned long *)&__m128d_result1) = 0x4160c00000000000; ++ *((unsigned long *)&__m128d_result0) = 0x4110000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff8000010f800000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000051649b6; ++ *((unsigned long *)&__m128i_op00) = 0x0000003e0000003f; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x41945926d8000000; ++ __m128d_out = __lsx_vffinth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe82fe0200000000; ++ *((unsigned long *)&__m128i_op00) = 0xfe82fe0200000000; ++ *((unsigned long *)&__m128d_result1) = 0xc177d01fe0000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128d_result1) = 0x40f0001000000000; ++ *((unsigned long *)&__m128d_result0) = 0x40f0001000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128d_result1) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x40f3fa0000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffe0001; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xc0fffff000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffintl_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-2.c +new file mode 100644 +index 000000000..f8839cfcd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-2.c +@@ -0,0 +1,264 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x03ff03ff03ff03ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x438ff81ff81ff820; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffint_d_l (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_op00) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128d_result1) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128d_result0) = 0x43d3e0000013e000; ++ __m128d_out = __lsx_vffint_d_l (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffint_d_l (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffint_d_l (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xbff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xbff0000000000000; ++ __m128d_out = __lsx_vffint_d_l (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0674c8868a74fc80; ++ *((unsigned long *)&__m128i_op00) = 0xfdce8003090b0906; ++ *((unsigned long *)&__m128d_result1) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128d_result0) = 0xc3818bffe7b7a7b8; ++ __m128d_out = __lsx_vffint_d_l (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((int *)&__m128_result3) = 0x4b7f00ff; ++ *((int *)&__m128_result2) = 0x4b7f00ff; ++ *((int *)&__m128_result1) = 0x4b7f00ff; ++ *((int *)&__m128_result0) = 0x4b7f00ff; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000401000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000004; ++ *((int *)&__m128_result3) = 0x40800000; ++ *((int *)&__m128_result2) = 0x4b800000; ++ *((int *)&__m128_result1) = 0x47800080; ++ *((int *)&__m128_result0) = 0x40800000; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x47000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x76f424887fffffff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x3f800000; ++ *((int *)&__m128_result1) = 0x4eede849; ++ *((int *)&__m128_result0) = 0x4f000000; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_op00) = 0xa352bfac9269e0aa; ++ *((int *)&__m128_result3) = 0xce23d33d; ++ *((int *)&__m128_result2) = 0x4edd53ea; ++ *((int *)&__m128_result1) = 0xceb95a81; ++ *((int *)&__m128_result0) = 0xcedb2c3f; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x3f800000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000003ff8; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x467fe000; ++ __m128_out = __lsx_vffint_s_w (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0xbf800000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xcf000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x5eff0000; ++ *((int *)&__m128_result2) = 0x5eff0000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000000e3; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfda9b23a624082fd; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((int *)&__m128_result3) = 0x43630000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xdc159371; ++ *((int *)&__m128_result0) = 0x4f7fff00; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000040; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x42800000; ++ *((int *)&__m128_result0) = 0x42800000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000100; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x43800000; ++ *((int *)&__m128_result0) = 0x43800000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op10) = 0x001effae001effae; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x59f7fd70; ++ *((int *)&__m128_result0) = 0x59f7fd70; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000ef0000000003b; ++ *((int *)&__m128_result3) = 0x577fff00; ++ *((int *)&__m128_result2) = 0x577fff00; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x596f0000; ++ __m128_out = __lsx_vffint_s_l (__m128i_op0, __m128i_op1); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-3.c +new file mode 100644 +index 000000000..9150e27ca +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vffint-3.c +@@ -0,0 +1,102 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x8493941335f5cc0c; ++ *((unsigned long *)&__m128i_op00) = 0x625a7312befcb21e; ++ *((unsigned long *)&__m128d_result1) = 0x43e092728266beba; ++ *((unsigned long *)&__m128d_result0) = 0x43d8969cc4afbf2d; ++ __m128d_out = __lsx_vffint_d_lu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffint_d_lu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffint_d_lu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vffint_d_lu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_wu (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001600000016; ++ *((unsigned long *)&__m128i_op00) = 0x0000001600000016; ++ *((int *)&__m128_result3) = 0x41b00000; ++ *((int *)&__m128_result2) = 0x41b00000; ++ *((int *)&__m128_result1) = 0x41b00000; ++ *((int *)&__m128_result0) = 0x41b00000; ++ __m128_out = __lsx_vffint_s_wu (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((int *)&__m128_result3) = 0x4f800000; ++ *((int *)&__m128_result2) = 0x4f800000; ++ *((int *)&__m128_result1) = 0x4f800000; ++ *((int *)&__m128_result0) = 0x4f800000; ++ __m128_out = __lsx_vffint_s_wu (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000442800007b50; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffff0204; ++ *((int *)&__m128_result3) = 0x46885000; ++ *((int *)&__m128_result2) = 0x46f6a000; ++ *((int *)&__m128_result1) = 0x4f800000; ++ *((int *)&__m128_result0) = 0x4f7fff02; ++ __m128_out = __lsx_vffint_s_wu (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_wu (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vffint_s_wu (__m128i_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_d.c +new file mode 100644 +index 000000000..c60ff2b46 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_d.c +@@ -0,0 +1,230 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++/* { dg-timeout 500 } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrint_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0003000300030003; ++ *((unsigned long *)&__m128d_op00) = 0x0003000700020005; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrint_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrint_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfrint_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00ff000100ff00fe; ++ *((unsigned long *)&__m128d_op00) = 0x00ff003000ff00a0; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrint_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfd200ed2fd370775; ++ *((unsigned long *)&__m128d_op00) = 0x96198318780e32c5; ++ *((unsigned long *)&__m128d_result1) = 0xfd200ed2fd370775; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfrint_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrne_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128d_op00) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128d_result1) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128d_result0) = 0xe0404041e0404041; ++ __m128d_out = __lsx_vfrintrne_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000080800000808; ++ *((unsigned long *)&__m128d_op00) = 0x0000080800000808; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrne_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfrintrne_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000868686868686; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrne_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrp_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000002000; ++ *((unsigned long *)&__m128d_op00) = 0xfffc002000000000; ++ *((unsigned long *)&__m128d_result1) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfffc002000000000; ++ __m128d_out = __lsx_vfrintrp_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x9c9c9c9c00000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfrintrp_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrp_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000007f00ff00ff; ++ *((unsigned long *)&__m128d_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128d_result1) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x3ff0000000000000; ++ __m128d_out = __lsx_vfrintrp_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000077af9450; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x3ff0000000000000; ++ __m128d_out = __lsx_vfrintrp_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff02ff1bff02ff23; ++ *((unsigned long *)&__m128d_op00) = 0x0000ffffff02fff4; ++ *((unsigned long *)&__m128d_result1) = 0xff02ff1bff02ff23; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrm_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrm_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op00) = 0x6a57a30ff0000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x6a57a30ff0000000; ++ __m128d_out = __lsx_vfrintrm_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000001300000013; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrm_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfrintrm_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffff02000000; ++ *((unsigned long *)&__m128d_op00) = 0x1f81e3779b97f4a8; ++ *((unsigned long *)&__m128d_result1) = 0xffffffff02000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrm_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0001000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrm_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrz_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x98ff98ff220e220d; ++ *((unsigned long *)&__m128d_op00) = 0xa2e1a2601ff01ff0; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfrintrz_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrz_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000abba7980; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ccf98000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrz_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128d_op00) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128d_result1) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128d_result0) = 0xfe03fe3ffe01fa21; ++ __m128d_out = __lsx_vfrintrz_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x5847b72626ce61ef; ++ *((unsigned long *)&__m128d_op00) = 0x110053f401e7cced; ++ *((unsigned long *)&__m128d_result1) = 0x5847b72626ce61ef; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfrintrz_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_s.c +new file mode 100644 +index 000000000..12cb02303 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrint_s.c +@@ -0,0 +1,350 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++/* { dg-timeout 500 } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00100010; ++ *((int *)&__m128_op02) = 0x00030000; ++ *((int *)&__m128_op01) = 0x00060002; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrint_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrint_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000001; ++ *((int *)&__m128_op02) = 0xca02f854; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0x00013fa0; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0xca02f854; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrint_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x000000ad; ++ *((int *)&__m128_op02) = 0x00007081; ++ *((int *)&__m128_op01) = 0x00000351; ++ *((int *)&__m128_op00) = 0x0000b5f2; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrint_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00ff00ef; ++ *((int *)&__m128_op02) = 0x00ff010f; ++ *((int *)&__m128_op01) = 0x00ff00ff; ++ *((int *)&__m128_op00) = 0x00ff010f; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrint_s (__m128_op0); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00130013; ++ *((int *)&__m128_op02) = 0x00130013; ++ *((int *)&__m128_op01) = 0x00130013; ++ *((int *)&__m128_op00) = 0x00130013; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x20202020; ++ *((int *)&__m128_op02) = 0x20202020; ++ *((int *)&__m128_op01) = 0x20202020; ++ *((int *)&__m128_op00) = 0x20207fff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x01f50000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00020004; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xfffbfffb; ++ *((int *)&__m128_op02) = 0xfffbfffb; ++ *((int *)&__m128_op01) = 0xfffbfffb; ++ *((int *)&__m128_op00) = 0xfffbfffb; ++ *((int *)&__m128_result3) = 0xfffbfffb; ++ *((int *)&__m128_result2) = 0xfffbfffb; ++ *((int *)&__m128_result1) = 0xfffbfffb; ++ *((int *)&__m128_result0) = 0xfffbfffb; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x0ff780a1; ++ *((int *)&__m128_op02) = 0x0efc01af; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xfe7f0000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0xfe7f0000; ++ __m128_out = __lsx_vfrintrne_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xefffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0xefffffff; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffff00; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffff00; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffff00; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffff00; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffb96b; ++ *((int *)&__m128_op02) = 0xffff57c9; ++ *((int *)&__m128_op01) = 0xffff6080; ++ *((int *)&__m128_op00) = 0xffff4417; ++ *((int *)&__m128_result3) = 0xffffb96b; ++ *((int *)&__m128_result2) = 0xffff57c9; ++ *((int *)&__m128_result1) = 0xffff6080; ++ *((int *)&__m128_result0) = 0xffff4417; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00ff00ff; ++ *((int *)&__m128_op02) = 0x00ff00ff; ++ *((int *)&__m128_op01) = 0x62cbf96e; ++ *((int *)&__m128_op00) = 0x4acfaf40; ++ *((int *)&__m128_result3) = 0x3f800000; ++ *((int *)&__m128_result2) = 0x3f800000; ++ *((int *)&__m128_result1) = 0x62cbf96e; ++ *((int *)&__m128_result0) = 0x4acfaf40; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00002000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x1fe02000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x3f800000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x3f800000; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x63636363; ++ *((int *)&__m128_op02) = 0x63abdf16; ++ *((int *)&__m128_op01) = 0x41f8e080; ++ *((int *)&__m128_op00) = 0x16161198; ++ *((int *)&__m128_result3) = 0x63636363; ++ *((int *)&__m128_result2) = 0x63abdf16; ++ *((int *)&__m128_result1) = 0x42000000; ++ *((int *)&__m128_result0) = 0x3f800000; ++ __m128_out = __lsx_vfrintrp_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrm_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xa5c4c774; ++ *((int *)&__m128_op02) = 0x856ba83b; ++ *((int *)&__m128_op01) = 0x8003caef; ++ *((int *)&__m128_op00) = 0x54691124; ++ *((int *)&__m128_result3) = 0xbf800000; ++ *((int *)&__m128_result2) = 0xbf800000; ++ *((int *)&__m128_result1) = 0xbf800000; ++ *((int *)&__m128_result0) = 0x54691124; ++ __m128_out = __lsx_vfrintrm_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00010002; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xff960015; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffd60015; ++ __m128_out = __lsx_vfrintrm_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0x3c992b2e; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffff730f; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0xffff730f; ++ __m128_out = __lsx_vfrintrz_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000016; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrz_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x18171615; ++ *((int *)&__m128_op02) = 0x17161514; ++ *((int *)&__m128_op01) = 0x16151413; ++ *((int *)&__m128_op00) = 0x15141312; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrz_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x62cbf96e; ++ *((int *)&__m128_op02) = 0x4acfaf40; ++ *((int *)&__m128_op01) = 0xf0bc9a52; ++ *((int *)&__m128_op00) = 0x78285a4a; ++ *((int *)&__m128_result3) = 0x62cbf96e; ++ *((int *)&__m128_result2) = 0x4acfaf40; ++ *((int *)&__m128_result1) = 0xf0bc9a52; ++ *((int *)&__m128_result0) = 0x78285a4a; ++ __m128_out = __lsx_vfrintrz_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfrintrz_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-1.c +new file mode 100644 +index 000000000..8d0d56632 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-1.c +@@ -0,0 +1,349 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000017fff9000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000040d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0008000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x004f1fcfd01f9f9f; ++ *((unsigned long *)&__m128d_op00) = 0x9f4fcfcfcf800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128d_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x9c7c266e3faa293c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000ffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000015d926c7; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000e41b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrp_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000777777777777; ++ *((unsigned long *)&__m128d_op00) = 0xffff7777ffff7777; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrp_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128d_op00) = 0x0000004000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0080000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xf4b6f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff80ffffffffff80; ++ *((unsigned long *)&__m128d_op00) = 0x0000ff80ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000b5207f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff007f00000000; ++ *((unsigned long *)&__m128d_op00) = 0xffff007f00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xbff0000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xc0f3fa0080000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffec060; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128d_op00) = 0x00012c8a0000a58a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_l_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-2.c +new file mode 100644 +index 000000000..5dba807f6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-2.c +@@ -0,0 +1,695 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00d4ccb8; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00124888; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfff00000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xfff00000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x80000000; ++ *((int *)&__m128_op02) = 0xffffd860; ++ *((int *)&__m128_op01) = 0x7fffffff; ++ *((int *)&__m128_op00) = 0x80000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00008000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00008000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff80ffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x7ffffffe; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x4f804f80; ++ *((int *)&__m128_op00) = 0x4f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0000007b; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000600; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x3f800000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x04870ba0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00009c7c; ++ *((int *)&__m128_op00) = 0x00007176; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0667ae56; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftinth_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x887c8beb; ++ *((int *)&__m128_op02) = 0x969e00f2; ++ *((int *)&__m128_op01) = 0x101f8b68; ++ *((int *)&__m128_op00) = 0x0b6f8095; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00020000; ++ *((int *)&__m128_op02) = 0x00020000; ++ *((int *)&__m128_op01) = 0x000001fc; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00020000; ++ *((int *)&__m128_op00) = 0xffff0001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0a752a55; ++ *((int *)&__m128_op01) = 0x0a753500; ++ *((int *)&__m128_op00) = 0xa9fa0d06; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrnel_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7fffffff; ++ *((int *)&__m128_op02) = 0x7fffffff; ++ *((int *)&__m128_op01) = 0x7fffffff; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x000d0254; ++ *((int *)&__m128_op02) = 0x0000007e; ++ *((int *)&__m128_op01) = 0x00000014; ++ *((int *)&__m128_op00) = 0x00140014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x39412488; ++ *((int *)&__m128_op00) = 0x80000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000014; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00010001; ++ *((int *)&__m128_op02) = 0x00010001; ++ *((int *)&__m128_op01) = 0x00010001; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x2e34594c; ++ *((int *)&__m128_op00) = 0x3b000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrpl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrml_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrml_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x7ffffffe; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrml_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00010001; ++ *((int *)&__m128_op02) = 0x00010001; ++ *((int *)&__m128_op01) = 0x00010001; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrml_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x7ff000ff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrml_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrml_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00ff00ff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfffefffe; ++ *((int *)&__m128_op02) = 0xfffeffff; ++ *((int *)&__m128_op01) = 0xfffefffe; ++ *((int *)&__m128_op00) = 0xfffeffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0000033a; ++ *((int *)&__m128_op02) = 0x0bde0853; ++ *((int *)&__m128_op01) = 0x0a960e6b; ++ *((int *)&__m128_op00) = 0x0a4f0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzl_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x7ffffffe; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrneh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xfffffffe; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrneh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrneh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000001; ++ *((int *)&__m128_op02) = 0x7ffeffff; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0x7ffeffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrneh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrneh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrneh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x80808080; ++ *((int *)&__m128_op00) = 0x80638063; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrph_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrph_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000080; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrph_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrph_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x80000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrmh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrmh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00ff00ff; ++ *((int *)&__m128_op02) = 0x00ff00ff; ++ *((int *)&__m128_op01) = 0x62cbf96e; ++ *((int *)&__m128_op00) = 0x4acfaf40; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrmh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0x0000ac26; ++ *((int *)&__m128_op01) = 0x00ff0000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrmh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x6420e020; ++ *((int *)&__m128_op02) = 0x8400c4e3; ++ *((int *)&__m128_op01) = 0x20c4e0c4; ++ *((int *)&__m128_op00) = 0xe0da6499; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfbffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x7bffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x18171615; ++ *((int *)&__m128_op02) = 0x17161514; ++ *((int *)&__m128_op01) = 0x16151413; ++ *((int *)&__m128_op00) = 0x15141312; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x046a09ec; ++ *((int *)&__m128_op00) = 0x009c0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrzh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x4f4f4f4f; ++ *((int *)&__m128_op02) = 0x4f4f4f4f; ++ *((int *)&__m128_op01) = 0x4f4f4f4f; ++ *((int *)&__m128_op00) = 0x4f4f4f4f; ++ *((unsigned long *)&__m128i_result1) = 0x00000000cf4f4f00; ++ *((unsigned long *)&__m128i_result0) = 0x00000000cf4f4f00; ++ __m128i_out = __lsx_vftintrzh_l_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-3.c +new file mode 100644 +index 000000000..7f6d2f4d1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-3.c +@@ -0,0 +1,1028 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128d_op10) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0000ffff; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x0000ffff; ++ *((int *)&__m128_op00) = 0x0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000001; ++ *((int *)&__m128_op02) = 0xfffffffe; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0xfffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00040100; ++ *((int *)&__m128_op01) = 0x00010001; ++ *((int *)&__m128_op00) = 0x00010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128d_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffffffffffff800; ++ *((unsigned long *)&__m128d_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffff00000080; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000001; ++ *((int *)&__m128_op02) = 0xfffffffe; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0xfffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000e0180000e810; ++ *((unsigned long *)&__m128d_op00) = 0x0000f0080000f800; ++ *((unsigned long *)&__m128d_op11) = 0x0000e0180000e810; ++ *((unsigned long *)&__m128d_op10) = 0x0000f0080000f800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffd30000; ++ *((int *)&__m128_op02) = 0x00130000; ++ *((int *)&__m128_op01) = 0xffd30000; ++ *((int *)&__m128_op00) = 0x00130000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xe1000000; ++ *((int *)&__m128_op02) = 0x4deb2610; ++ *((int *)&__m128_op01) = 0xe101e001; ++ *((int *)&__m128_op00) = 0x4dec4089; ++ *((unsigned long *)&__m128i_result1) = 0x800000001d64c200; ++ *((unsigned long *)&__m128i_result0) = 0x800000001d881120; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x76f42488; ++ *((int *)&__m128_op00) = 0x80000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff00000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000001f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0202f5f80000ff00; ++ *((unsigned long *)&__m128d_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x003fffc0; ++ *((int *)&__m128_op02) = 0xffc0003f; ++ *((int *)&__m128_op01) = 0xffc0ffc0; ++ *((int *)&__m128_op00) = 0x003f003f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffff7fffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffff8000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x42652524; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000003900000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff00ff7f; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0x7f800000; ++ *((int *)&__m128_op01) = 0x2d1da85b; ++ *((int *)&__m128_op00) = 0x7f800000; ++ *((unsigned long *)&__m128i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fffffff; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128d_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x80307028; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x8040007f; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000fefefe6a; ++ *((unsigned long *)&__m128d_op00) = 0x00000000c2bac2c2; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128d_op11) = 0x000000004fc04f81; ++ *((unsigned long *)&__m128d_op10) = 0x000000004fc04f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000000000001f; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000001f; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000003a0000003a; ++ *((unsigned long *)&__m128d_op11) = 0x37c0001000000000; ++ *((unsigned long *)&__m128d_op10) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000068; ++ *((unsigned long *)&__m128d_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128d_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x4429146a7b4c88b2; ++ *((unsigned long *)&__m128d_op00) = 0xe22b3595efa4aa0c; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff80000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0001000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000400000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000fffffff5; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128d_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128d_op11) = 0xe7e5560400010001; ++ *((unsigned long *)&__m128d_op10) = 0xe7e5dabf00010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x03050302; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x03010302; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000600007fff; ++ *((unsigned long *)&__m128d_op00) = 0x00000008ffffa209; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x046a09ec009c0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x000aa822; ++ *((int *)&__m128_op02) = 0xa79308f6; ++ *((int *)&__m128_op01) = 0x03aa355e; ++ *((int *)&__m128_op00) = 0x1d37b5a1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffff00; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrne_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00001802; ++ *((int *)&__m128_op00) = 0x041b0013; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vftintrp_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x004200a000000000; ++ *((unsigned long *)&__m128d_op00) = 0x004200a000200000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128d_op00) = 0x0001000101fd01fe; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000c2f90000bafa; ++ *((unsigned long *)&__m128d_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x00000000fffff800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff80ffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x7ffffffe; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0101080408040804; ++ *((unsigned long *)&__m128d_op00) = 0x0804080407040804; ++ *((unsigned long *)&__m128d_op11) = 0x0101080408040804; ++ *((unsigned long *)&__m128d_op10) = 0x0804080407040804; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00010001; ++ *((int *)&__m128_op02) = 0x00010001; ++ *((int *)&__m128_op01) = 0x00010001; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vftintrp_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000003ffda00f3; ++ *((unsigned long *)&__m128d_op00) = 0x00000003ffda00f3; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfffffadf; ++ *((int *)&__m128_op02) = 0xfedbfefe; ++ *((int *)&__m128_op01) = 0x5f5f7bfe; ++ *((int *)&__m128_op00) = 0xdefb5ada; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff80000000; ++ __m128i_out = __lsx_vftintrp_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffa6ff91fdd8ef77; ++ *((unsigned long *)&__m128d_op00) = 0x061202bffb141c38; ++ *((unsigned long *)&__m128d_op11) = 0xfefffffffed08f77; ++ *((unsigned long *)&__m128d_op10) = 0x8160cdd2f365ed0d; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000001; ++ *((int *)&__m128_op02) = 0x084314a6; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0x084314a6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vftintrp_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x3f413f4100000000; ++ *((unsigned long *)&__m128d_op00) = 0x7f801fe000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000017fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128d_op00) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128d_op11) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128d_op10) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vftintrp_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x3a800000; ++ *((int *)&__m128_op02) = 0x3a800000; ++ *((int *)&__m128_op01) = 0x000ef000; ++ *((int *)&__m128_op00) = 0x0000003b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vftintrp_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x10404000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x09610001; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0000001a; ++ *((int *)&__m128_op02) = 0xfffffff7; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0800080008000800; ++ *((unsigned long *)&__m128d_op10) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000000202fe02; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op10) = 0xffff00fc0000ff02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00040004; ++ *((int *)&__m128_op02) = 0x00040004; ++ *((int *)&__m128_op01) = 0x00040004; ++ *((int *)&__m128_op00) = 0x00040004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00ffff00; ++ *((int *)&__m128_op02) = 0xff00ff00; ++ *((int *)&__m128_op01) = 0x00ffff00; ++ *((int *)&__m128_op00) = 0xff00ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x013ec13e; ++ *((int *)&__m128_op01) = 0xc03fc03f; ++ *((int *)&__m128_op00) = 0xc0ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffdfffffff8; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x7fffffff7ffffffb; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x43800000; ++ *((int *)&__m128_op00) = 0x43800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000100; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000014; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrm_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000017fda829; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffff7; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x80307028ffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x8040007fffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff84fff4; ++ *((int *)&__m128_op02) = 0xff84fff4; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x7fff0007e215b122; ++ *((unsigned long *)&__m128d_op10) = 0x7ffeffff7bfff828; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x07ffc000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffff0000; ++ *((int *)&__m128_op00) = 0x0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xf039b8c0; ++ *((int *)&__m128_op02) = 0xc61e81ef; ++ *((int *)&__m128_op01) = 0x6db7da53; ++ *((int *)&__m128_op00) = 0xfbd2e34b; ++ *((unsigned long *)&__m128i_result1) = 0x80000000ffffd860; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff80000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00020000; ++ *((int *)&__m128_op00) = 0xffff0001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00027113; ++ *((int *)&__m128_op02) = 0x50a27112; ++ *((int *)&__m128_op01) = 0x00d57017; ++ *((int *)&__m128_op00) = 0x94027113; ++ *((unsigned long *)&__m128i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff80ff80; ++ *((int *)&__m128_op02) = 0x7e017f01; ++ *((int *)&__m128_op01) = 0x7f3b7f3f; ++ *((int *)&__m128_op00) = 0x7f3b7f21; ++ *((unsigned long *)&__m128i_result1) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vftintrz_w_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffee; ++ *((unsigned long *)&__m128d_op00) = 0x00000000011ff040; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x00000000047fe2f0; ++ *((unsigned long *)&__m128d_op10) = 0x00000000047fe2f0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_w_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-4.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-4.c +new file mode 100644 +index 000000000..9c5bb9131 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vftint-4.c +@@ -0,0 +1,345 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x0000c77c; ++ *((int *)&__m128_op02) = 0x000047cd; ++ *((int *)&__m128_op01) = 0x0000c0f1; ++ *((int *)&__m128_op00) = 0x00006549; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0xffffffee; ++ *((int *)&__m128_op00) = 0x00000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0000ffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x63636363; ++ *((int *)&__m128_op02) = 0x63636363; ++ *((int *)&__m128_op01) = 0x63636363; ++ *((int *)&__m128_op00) = 0x63636363; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vftint_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xfffffffe; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x02020004; ++ *((int *)&__m128_op02) = 0x02020202; ++ *((int *)&__m128_op01) = 0x00002000; ++ *((int *)&__m128_op00) = 0x00010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7fff7fff; ++ *((int *)&__m128_op02) = 0x7fff7fff; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0x0000003f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x000000ff; ++ *((int *)&__m128_op02) = 0x808000ff; ++ *((int *)&__m128_op01) = 0x000000ff; ++ *((int *)&__m128_op00) = 0x808000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x7f7f7f7f; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0x00000010; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00002000; ++ *((int *)&__m128_op02) = 0x00002000; ++ *((int *)&__m128_op01) = 0x10000000; ++ *((int *)&__m128_op00) = 0x10000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x67eb85af; ++ *((int *)&__m128_op02) = 0xb2ebb000; ++ *((int *)&__m128_op01) = 0xc8847ef6; ++ *((int *)&__m128_op00) = 0xed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_wu_s (__m128_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000400000004000; ++ *((unsigned long *)&__m128d_op00) = 0x0000400000007004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x3c600000ff800000; ++ *((unsigned long *)&__m128d_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x6a57a30ff0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x40f0001000000000; ++ *((unsigned long *)&__m128d_op00) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000010001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010001; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000014; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128d_op00) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000009c83e21a; ++ *((unsigned long *)&__m128d_op00) = 0x0000000022001818; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftint_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0080000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x800000001d64c200; ++ *((unsigned long *)&__m128d_op00) = 0x800000001d881120; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000f0009d3c; ++ *((unsigned long *)&__m128d_op00) = 0x000000016fff9dff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000040a04000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000040a04000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m128d_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x03fc03fc03fc03fc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vftintrz_lu_d (__m128d_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-handling-and-shuff.patch
Added
@@ -0,0 +1,5411 @@ +From ab7f1db887733fabf41c7a39730c48376e29100c Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 11:34:56 +0800 +Subject: PATCH 096/124 LoongArch: Add tests for SX vector handling and + shuffle instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vbsll.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbsrl.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vextrins.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vilvh.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vilvl.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vinsgr2vr.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vpackev.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vpackod.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vpickev.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vpickod.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vpickve2gr.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vpremi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vreplgr2vr.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vreplve.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vreplvei.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vshuf.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vshuf4i.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vbsll.c | 83 +++ + .../loongarch/vector/lsx/lsx-vbsrl.c | 55 ++ + .../loongarch/vector/lsx/lsx-vextrins.c | 479 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vilvh.c | 353 +++++++++++++ + .../loongarch/vector/lsx/lsx-vilvl.c | 327 ++++++++++++ + .../loongarch/vector/lsx/lsx-vinsgr2vr.c | 278 ++++++++++ + .../loongarch/vector/lsx/lsx-vpackev.c | 452 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vpackod.c | 461 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vpickev.c | 362 +++++++++++++ + .../loongarch/vector/lsx/lsx-vpickod.c | 336 ++++++++++++ + .../loongarch/vector/lsx/lsx-vpickve2gr.c | 488 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vpremi.c | 20 + + .../loongarch/vector/lsx/lsx-vreplgr2vr.c | 212 ++++++++ + .../loongarch/vector/lsx/lsx-vreplve.c | 300 +++++++++++ + .../loongarch/vector/lsx/lsx-vreplvei.c | 293 +++++++++++ + .../loongarch/vector/lsx/lsx-vshuf.c | 394 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vshuf4i.c | 348 +++++++++++++ + 17 files changed, 5241 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsll.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsrl.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextrins.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvh.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvl.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vinsgr2vr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackev.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackod.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickev.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickod.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickve2gr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpremi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplgr2vr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplve.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplvei.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf4i.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsll.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsll.c +new file mode 100644 +index 000000000..34246c551 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsll.c +@@ -0,0 +1,83 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ffffff000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffff000000ff00; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0xff00000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op00) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result1) = 0x0a00000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_op00) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_result1) = 0x4101010141010100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001580000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsll_v (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsrl.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsrl.c +new file mode 100644 +index 000000000..986b7d566 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbsrl.c +@@ -0,0 +1,55 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000401000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000040100; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010000; ++ __m128i_out = __lsx_vbsrl_v (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000003fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x000000003fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x003fffffff000000; ++ __m128i_out = __lsx_vbsrl_v (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0005fe0300010101; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result0) = 0xfe03000101010000; ++ __m128i_out = __lsx_vbsrl_v (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbsrl_v (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op00) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000d3259a; ++ __m128i_out = __lsx_vbsrl_v (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextrins.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextrins.c +new file mode 100644 +index 000000000..8d4158b57 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextrins.c +@@ -0,0 +1,479 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff00000000; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x92); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xc2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0200020002000200; ++ *((unsigned long *)&__m128i_op10) = 0x0200020002000200; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff02000200; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0c03e17edd781b11; ++ *((unsigned long *)&__m128i_op00) = 0x342caf9be55700b5; ++ *((unsigned long *)&__m128i_op11) = 0x0000040400000383; ++ *((unsigned long *)&__m128i_op10) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128i_result1) = 0x0c03e17edd781b11; ++ *((unsigned long *)&__m128i_result0) = 0x342caf9bffff1fff; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0xcc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xc6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000a16316b0; ++ *((unsigned long *)&__m128i_op00) = 0x0000000063636363; ++ *((unsigned long *)&__m128i_op11) = 0x16161616a16316b0; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x00000000a16316b0; ++ *((unsigned long *)&__m128i_result0) = 0x16161616a16316b0; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0xa7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff489b693120950; ++ *((unsigned long *)&__m128i_op10) = 0xfffc45a851c40c18; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffc45a851c40c18; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x48); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0xcc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000005d5d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x41); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffefefe6a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c2bac2c2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fefefe6a; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c2bac2c2; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x7c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7ffffffeffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x4080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0xff80ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7ffffffeffffffff; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xe6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op00) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000a0000000a; ++ *((unsigned long *)&__m128i_op10) = 0x0000000a00000009; ++ *((unsigned long *)&__m128i_result1) = 0x000a000a0000000a; ++ *((unsigned long *)&__m128i_result0) = 0x000a000a000a000a; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0xaf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff80000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x67); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004fcfcfd01f9f9f; ++ *((unsigned long *)&__m128i_op00) = 0x9f4fcfcfcf800000; ++ *((unsigned long *)&__m128i_op11) = 0x004fcfcfd01f9f9f; ++ *((unsigned long *)&__m128i_op10) = 0x9f4fcfcfcf800000; ++ *((unsigned long *)&__m128i_result1) = 0x004f1fcfd01f9f9f; ++ *((unsigned long *)&__m128i_result0) = 0x9f4fcfcfcf800000; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xda); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x75b043c4d17db125; ++ *((unsigned long *)&__m128i_op00) = 0xeef8227b596117b1; ++ *((unsigned long *)&__m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x75b043c4d17db125; ++ *((unsigned long *)&__m128i_result0) = 0xeef8227b4f8017b1; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x027c027c000027c0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000de32400; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x027c027c000027c0; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0x77); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363797c63996399; ++ *((unsigned long *)&__m128i_op00) = 0x171f0a1f6376441f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x6363797c63990099; ++ *((unsigned long *)&__m128i_result0) = 0x171f0a1f6376441f; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0x94); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0bd80bd80bdfffff; ++ *((unsigned long *)&__m128i_op00) = 0x0bd80bd80bd80000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0bd80bd80bd80000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0xf9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x41dfbe1f41e0ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffc2ffe000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffc100010001; ++ *((unsigned long *)&__m128i_result1) = 0x41dfbe1f41e0ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffc100010001; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0xec); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xe93d0bd19ff0c170; ++ *((unsigned long *)&__m128i_op10) = 0x5237c1bac9eadf55; ++ *((unsigned long *)&__m128i_result1) = 0x5237c1baffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x7d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffbd994889; ++ *((unsigned long *)&__m128i_op10) = 0x000000000a092444; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000890000000000; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0x58); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000fea0000fffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffff8607db959f; ++ *((unsigned long *)&__m128i_op10) = 0xff0cff78ff96ff14; ++ *((unsigned long *)&__m128i_result1) = 0x00000fea0000fffe; ++ *((unsigned long *)&__m128i_result0) = 0xff0cff78ff96ff14; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0xc2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x01ef013f01e701f8; ++ *((unsigned long *)&__m128i_op10) = 0x35bb8d32b2625c00; ++ *((unsigned long *)&__m128i_result1) = 0x00008d3200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0xea); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8003000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x4040ffffc0400004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8003000000020000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x64); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x74); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op00) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_result0) = 0xff000001ffff9515; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0x67); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xf4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xc1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x71); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x82); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xd5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0xf3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbbe5560400010001; ++ *((unsigned long *)&__m128i_op00) = 0xe7e5dabf00010001; ++ *((unsigned long *)&__m128i_op11) = 0xbbe5560400010001; ++ *((unsigned long *)&__m128i_op10) = 0xe7e5dabf00010001; ++ *((unsigned long *)&__m128i_result1) = 0xe7e5560400010001; ++ *((unsigned long *)&__m128i_result0) = 0xe7e5dabf00010001; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0xf3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x5d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x24); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xb6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x975ca6046e2e4889; ++ *((unsigned long *)&__m128i_op10) = 0x1748c4f9ed1a5870; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1748c4f9ed1a5870; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x6a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffc606ec5; ++ *((unsigned long *)&__m128i_op10) = 0x0000000014155445; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0x76); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000024170000; ++ *((unsigned long *)&__m128i_op11) = 0x000aa822a79308f6; ++ *((unsigned long *)&__m128i_op10) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_result1) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_result0) = 0x0000000024170000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op10) = 0x0000000024170000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0x56); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vextrins_b (__m128i_op0, __m128i_op1, 0xc5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000034; ++ *((unsigned long *)&__m128i_op11) = 0x01017f3c00000148; ++ *((unsigned long *)&__m128i_op10) = 0x117d7f7b093d187f; ++ *((unsigned long *)&__m128i_result1) = 0x117d7f7b093d187f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000034; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x70); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x01533b5e7489ae24; ++ *((unsigned long *)&__m128i_op00) = 0xe519ab7e71e33848; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x01533b5e7489ae24; ++ *((unsigned long *)&__m128i_result0) = 0xffffab7e71e33848; ++ __m128i_out = __lsx_vextrins_h (__m128i_op0, __m128i_op1, 0xbc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff760386bdae46; ++ *((unsigned long *)&__m128i_op10) = 0xc1fc7941bc7e00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff7603; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0xc3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xffff2356fe165486; ++ *((unsigned long *)&__m128i_op11) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op10) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_result1) = 0x0000003b0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff2356fe165486; ++ __m128i_out = __lsx_vextrins_w (__m128i_op0, __m128i_op1, 0x70); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextrins_d (__m128i_op0, __m128i_op1, 0x8a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvh.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvh.c +new file mode 100644 +index 000000000..aa802b295 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvh.c +@@ -0,0 +1,353 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007fffff00000000; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x195f307a5d04acbb; ++ *((unsigned long *)&__m128i_op00) = 0x6a1a3fbb3c90260e; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x195f307a5d04acbb; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8644000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xaed495f03343a685; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffbe6ed563; ++ *((unsigned long *)&__m128i_result1) = 0x8644ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000fffe; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_op00) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_op11) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op10) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000e13; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000e13; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op00) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000a000a00000000; ++ *((unsigned long *)&__m128i_result0) = 0x000a000a00000000; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0xff00ff00ff00ff00; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x000000004f804f80; ++ *((unsigned long *)&__m128i_result0) = 0x000000004f804f80; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x004f0080004f0080; ++ *((unsigned long *)&__m128i_result0) = 0x004f0080004f0080; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ffa7f8ff81; ++ *((unsigned long *)&__m128i_op10) = 0x0000003f0080ffc0; ++ *((unsigned long *)&__m128i_result1) = 0x000000007fff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000a7f87fffff81; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00003f8000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00003f8000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000ffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x000080003f80ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x202020202020ff20; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x2000200020002000; ++ *((unsigned long *)&__m128i_result0) = 0x2000200020002000; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0808ffff0808ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0808ffff0808ffff; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000157; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010058; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010058; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000200; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x0002008360500088; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000008; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000f3040705; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0xff00ff00ff00ff00; ++ __m128i_out = __lsx_vilvh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vilvh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvl.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvl.c +new file mode 100644 +index 000000000..88c66f220 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vilvl.c +@@ -0,0 +1,327 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_op10) = 0x000201000000000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000201000000000b; ++ __m128i_out = __lsx_vilvl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffffffc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffcff; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7404443064403aec; ++ *((unsigned long *)&__m128i_op00) = 0x0000d6eefefc0498; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff7f800000; ++ *((unsigned long *)&__m128i_op10) = 0x2d1da85b7f800000; ++ *((unsigned long *)&__m128i_result1) = 0x002d001dd6a8ee5b; ++ *((unsigned long *)&__m128i_result0) = 0xfe7ffc8004009800; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op10) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_result0) = 0x0000001000000010; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000c0000bd49; ++ *((unsigned long *)&__m128i_op00) = 0x0000000c7fff000c; ++ *((unsigned long *)&__m128i_op11) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000c7fff000c; ++ *((unsigned long *)&__m128i_result0) = 0x1000100010001000; ++ __m128i_out = __lsx_vilvl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff0000007f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vilvl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001e8e1d8; ++ *((unsigned long *)&__m128i_op00) = 0x000000e400000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000001e8e1d8; ++ *((unsigned long *)&__m128i_op10) = 0x000000e400000001; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000e4e4; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000101; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0008000000000000; ++ __m128i_out = __lsx_vilvl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vilvl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffe0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffe0; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbafebb00ffd500fe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff80005613; ++ *((unsigned long *)&__m128i_op10) = 0x007f800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000807f80808000; ++ *((unsigned long *)&__m128i_result0) = 0x80006b0000000b00; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000080808000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_result0) = 0x0080006b0000000b; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc0808000c0808000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xc080800000000000; ++ *((unsigned long *)&__m128i_result0) = 0xc080800000000000; ++ __m128i_out = __lsx_vilvl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op00) = 0x00ff010300ff0103; ++ *((unsigned long *)&__m128i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007ffff001000300; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff0001000300; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_result1) = 0x007f00ff00ff00fe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0x8); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x0014001400140000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001400000014; ++ *((unsigned long *)&__m128i_result0) = 0x0000001400000000; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000009c007c00; ++ *((unsigned long *)&__m128i_result0) = 0x0000000071007600; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000060002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000060002; ++ *((unsigned long *)&__m128i_op11) = 0xe4c8b96e2560afe9; ++ *((unsigned long *)&__m128i_op10) = 0xc001a1867fffa207; ++ *((unsigned long *)&__m128i_result1) = 0x0000c0010000a186; ++ *((unsigned long *)&__m128i_result0) = 0x00067fff0002a207; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000014414104505; ++ *((unsigned long *)&__m128i_op00) = 0x1011050040004101; ++ *((unsigned long *)&__m128i_op11) = 0x0000014414104505; ++ *((unsigned long *)&__m128i_op10) = 0x1011050040004101; ++ *((unsigned long *)&__m128i_result1) = 0x1010111105050000; ++ *((unsigned long *)&__m128i_result0) = 0x4040000041410101; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vilvl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffac5cffffac5c; ++ *((unsigned long *)&__m128i_op00) = 0xffffac5cffffac5c; ++ *((unsigned long *)&__m128i_op11) = 0x010169d9010169d9; ++ *((unsigned long *)&__m128i_op10) = 0x01010287010146a1; ++ *((unsigned long *)&__m128i_result1) = 0xff01ff01ac025c87; ++ *((unsigned long *)&__m128i_result0) = 0xff01ff01ac465ca1; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff01ff01ac025c87; ++ *((unsigned long *)&__m128i_op00) = 0xff01ff01ac465ca1; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff01ff0100000000; ++ *((unsigned long *)&__m128i_result0) = 0xac465ca100000000; ++ __m128i_out = __lsx_vilvl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000eefff; ++ *((unsigned long *)&__m128i_op00) = 0xf8e1a03affffe3e2; ++ *((unsigned long *)&__m128i_op11) = 0x00000000246d9755; ++ *((unsigned long *)&__m128i_op10) = 0x000000002427c2ee; ++ *((unsigned long *)&__m128i_result1) = 0xf8e10000a03a0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff2427e3e2c2ee; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffe4ffe4ffe4ffe4; ++ *((unsigned long *)&__m128i_op00) = 0xffe4ffe4ffe4ffe4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000011ff040; ++ *((unsigned long *)&__m128i_result1) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128i_result0) = 0xff01e41ffff0e440; ++ __m128i_out = __lsx_vilvl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128i_op00) = 0xff01e41ffff0ffff; ++ *((unsigned long *)&__m128i_op11) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff01ffffe41f0000; ++ *((unsigned long *)&__m128i_result0) = 0xfff00000ffff0000; ++ __m128i_out = __lsx_vilvl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vinsgr2vr.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vinsgr2vr.c +new file mode 100644 +index 000000000..2b9dcc0b5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vinsgr2vr.c +@@ -0,0 +1,278 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000007942652524; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4265252400000000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ int_op1 = 0x0000007942652524; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff2524ffffffff; ++ __m128i_out = __lsx_vinsgr2vr_h (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000210011084; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vinsgr2vr_d (__m128i_op0, long_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vinsgr2vr_h (__m128i_op0, int_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0080000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0080000000000000; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op00) = 0x5d5d5d5d5d5d5d55; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_result0) = 0x5d5d5d005d5d5d55; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x1); ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vinsgr2vr_h (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vinsgr2vr_h (__m128i_op0, int_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x2020202020202020; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_result0) = 0x202020202020ff20; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op00) = 0x00fe01fc0005fff4; ++ int_op1 = 0x0000000020202020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000820202020; ++ *((unsigned long *)&__m128i_result0) = 0x00fe01fc0005fff4; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_op00) = 0xffffffbfffffffbf; ++ long_op1 = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_result1) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000003a24; ++ __m128i_out = __lsx_vinsgr2vr_d (__m128i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ef8000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ef8000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7ef8000000000000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ long_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_d (__m128i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff000000ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001000; ++ int_op1 = 0x000000007ff00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001000; ++ __m128i_out = __lsx_vinsgr2vr_h (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000020006; ++ *((unsigned long *)&__m128i_result1) = 0x0000060000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000020006; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000600; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000003; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_h (__m128i_op0, int_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000001f1f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x00ff000000001f1f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ long_op1 = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vinsgr2vr_d (__m128i_op0, long_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffff0000; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000ffffff0000; ++ __m128i_out = __lsx_vinsgr2vr_w (__m128i_op0, int_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vinsgr2vr_h (__m128i_op0, int_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x04faf60009f5f092; ++ *((unsigned long *)&__m128i_op00) = 0x04fafa9200000000; ++ int_op1 = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x04faf600fff5f092; ++ *((unsigned long *)&__m128i_result0) = 0x04fafa9200000000; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vinsgr2vr_b (__m128i_op0, int_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackev.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackev.c +new file mode 100644 +index 000000000..030e87fd8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackev.c +@@ -0,0 +1,452 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001802041b0013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00001802041b0013; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff000000ff; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xf4b6f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_result1) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xf4b6f3f52f4ef4a8; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_op10) = 0x203e16d116de012b; ++ *((unsigned long *)&__m128i_result1) = 0x00f900d7003d00e4; ++ *((unsigned long *)&__m128i_result0) = 0x003e00d100de002b; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000000; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc2f9bafac2fac2fa; ++ *((unsigned long *)&__m128i_op11) = 0xbdf077eee7e20468; ++ *((unsigned long *)&__m128i_op10) = 0xe3b1cc6953e7db29; ++ *((unsigned long *)&__m128i_result1) = 0x00000000e7e20468; ++ *((unsigned long *)&__m128i_result0) = 0xc2fac2fa53e7db29; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf8f8e018f8f8e810; ++ *((unsigned long *)&__m128i_op10) = 0xf8f8f008f8f8f800; ++ *((unsigned long *)&__m128i_result1) = 0x0000e0180000e810; ++ *((unsigned long *)&__m128i_result0) = 0x0000f0080000f800; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1211100f11100f0e; ++ *((unsigned long *)&__m128i_op00) = 0x100f0e0d0f0e0d0c; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result1) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_result0) = 0x0f000d200e000c20; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xe3e3e3e3e3e3e3e3; ++ *((unsigned long *)&__m128i_op10) = 0xe3e3e3e3e3e3e3e3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xe3e3e3e3e3e3e3e3; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00007ffe00007ffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001c00ffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00007f7f00007f7f; ++ *((unsigned long *)&__m128i_result1) = 0x000001000f00fe00; ++ *((unsigned long *)&__m128i_result0) = 0x0000017fff00fe7f; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000f0009d3c; ++ *((unsigned long *)&__m128i_op00) = 0x000000016fff9d3d; ++ *((unsigned long *)&__m128i_op11) = 0xfffff000f0008d3c; ++ *((unsigned long *)&__m128i_op10) = 0xfffff0016fff8d3d; ++ *((unsigned long *)&__m128i_result1) = 0x00ff000000003c3c; ++ *((unsigned long *)&__m128i_result0) = 0x00ff0101ffff3d3d; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op10) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000958affff995d; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100013fa0; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffefffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffefffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffefefffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002fffefffd0001; ++ *((unsigned long *)&__m128i_op11) = 0x1202120212021202; ++ *((unsigned long *)&__m128i_op10) = 0x1202120212021202; ++ *((unsigned long *)&__m128i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result0) = 0x0202fe02fd020102; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5a6f5c53ebed3faa; ++ *((unsigned long *)&__m128i_op00) = 0xa36aca4435b8b8e1; ++ *((unsigned long *)&__m128i_op11) = 0x5a6f5c53ebed3faa; ++ *((unsigned long *)&__m128i_op10) = 0xa36aca4435b8b8e1; ++ *((unsigned long *)&__m128i_result1) = 0x5c535c533faa3faa; ++ *((unsigned long *)&__m128i_result0) = 0xca44ca44b8e1b8e1; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op00) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op11) = 0x77c0404a4000403a; ++ *((unsigned long *)&__m128i_op10) = 0x77c03fd640003fc6; ++ *((unsigned long *)&__m128i_result1) = 0x04c0044a0400043a; ++ *((unsigned long *)&__m128i_result0) = 0x04c004d6040004c6; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000006362ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000d0000000d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000dffff000d; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000002002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200020002; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op00) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op11) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op10) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_result1) = 0x2080208020802080; ++ *((unsigned long *)&__m128i_result0) = 0x2080208020802080; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000b; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000001b0000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000001b0000; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000053a; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff9000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffc000400000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffc000400000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001f00000000; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xe593c8c4e593c8c4; ++ *((unsigned long *)&__m128i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0x8080000080800000; ++ *((unsigned long *)&__m128i_result0) = 0x9380c4009380c400; ++ __m128i_out = __lsx_vpackev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc2007aff230027; ++ *((unsigned long *)&__m128i_op00) = 0x0080005eff600001; ++ *((unsigned long *)&__m128i_op11) = 0x01017f3c00000148; ++ *((unsigned long *)&__m128i_op10) = 0x117d7f7b093d187f; ++ *((unsigned long *)&__m128i_result1) = 0xff23002700000148; ++ *((unsigned long *)&__m128i_result0) = 0xff600001093d187f; ++ __m128i_out = __lsx_vpackev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0002711250a27112; ++ *((unsigned long *)&__m128i_op10) = 0x00d2701294027112; ++ *((unsigned long *)&__m128i_result1) = 0xffff7112ffff7112; ++ *((unsigned long *)&__m128i_result0) = 0xffff7012ffff7112; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb020302101b03; ++ *((unsigned long *)&__m128i_op00) = 0x020310d0c0030220; ++ *((unsigned long *)&__m128i_op11) = 0x30eb020302101b03; ++ *((unsigned long *)&__m128i_op10) = 0x020310d0c0030220; ++ *((unsigned long *)&__m128i_result1) = 0x020310d0c0030220; ++ *((unsigned long *)&__m128i_result0) = 0x020310d0c0030220; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000eefff; ++ *((unsigned long *)&__m128i_op00) = 0xf8e1a03affffe3e2; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000eefff; ++ *((unsigned long *)&__m128i_op10) = 0xf8e1a03affffe3e2; ++ *((unsigned long *)&__m128i_result1) = 0x00000000efffefff; ++ *((unsigned long *)&__m128i_result0) = 0xa03aa03ae3e2e3e2; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x02b010f881a281a2; ++ *((unsigned long *)&__m128i_op10) = 0x27b169bbb8140001; ++ *((unsigned long *)&__m128i_result1) = 0x000010f8000081a2; ++ *((unsigned long *)&__m128i_result0) = 0x000069bb00000001; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackod.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackod.c +new file mode 100644 +index 000000000..783eedae1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpackod.c +@@ -0,0 +1,461 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000201000000000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000020100; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffc002000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00003ff000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fffc00000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m128i_op11) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001010000; ++ *((unsigned long *)&__m128i_result1) = 0x03574e3a03574e3a; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000001fe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000003a; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000015; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128i_op00) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128i_op11) = 0x803f800080000000; ++ *((unsigned long *)&__m128i_op10) = 0xe0404041c0404040; ++ *((unsigned long *)&__m128i_result1) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128i_result0) = 0x803f800080000000; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfe80000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00fe000000000000; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfe80ffffffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfe80ff80ffff0000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_op00) = 0x0f000d200e000c20; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x11000f2000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0f000d2000000000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_op00) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_op11) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_op10) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_result1) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result0) = 0x4f804f804f804f80; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000c000ffffc000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000006f00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000c00000000000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_result1) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffcfffcfffcfffc; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op00) = 0x2222272011111410; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op10) = 0x2222272011111410; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ff00; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffef8; ++ *((unsigned long *)&__m128i_op10) = 0xffdfffdfffdffee0; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffffffdfffdf; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0010100000100000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100000101000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000000010; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e19181716; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x01203f1e3d1c3b1a; ++ *((unsigned long *)&__m128i_op10) = 0x3918371635143312; ++ *((unsigned long *)&__m128i_result1) = 0x21011f3f193d173b; ++ *((unsigned long *)&__m128i_result0) = 0xff39ff37ff35ff33; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000003fbf3fbf; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7ff8; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff3fbfffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff80806362; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff00008080; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ff; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000100000000fc; ++ *((unsigned long *)&__m128i_op00) = 0x00000100000000fc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000000; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0404050404040404; ++ *((unsigned long *)&__m128i_op10) = 0x0404050404040404; ++ *((unsigned long *)&__m128i_result1) = 0x0000000004040504; ++ *((unsigned long *)&__m128i_result0) = 0x0000000004040504; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000807f80808000; ++ *((unsigned long *)&__m128i_op00) = 0x80006b0000000b00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x8000807f00000000; ++ *((unsigned long *)&__m128i_result0) = 0x80006b0080808080; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000400000004000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00004000ffffffff; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000080008; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000001400000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000000000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffefffe00000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffe00000000; ++ __m128i_out = __lsx_vpackod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op10) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_result1) = 0x00cd006300cd0063; ++ *((unsigned long *)&__m128i_result0) = 0x00cd006300cd0063; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000aa822a79308f6; ++ *((unsigned long *)&__m128i_op00) = 0x03aa558e1d37b5a1; ++ *((unsigned long *)&__m128i_op11) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff80fd820000; ++ *((unsigned long *)&__m128i_result1) = 0x000aa822a79308f6; ++ *((unsigned long *)&__m128i_result0) = 0x00000000084d12ce; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x2e34594c3b000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x002e0059003b0000; ++ __m128i_out = __lsx_vpackod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001e001e001e001e; ++ *((unsigned long *)&__m128i_op00) = 0x001e001e001e001e; ++ *((unsigned long *)&__m128i_op11) = 0xffaeffaeffaeffae; ++ *((unsigned long *)&__m128i_op10) = 0xffaeffaeffaeffae; ++ *((unsigned long *)&__m128i_result1) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_result0) = 0x001effae001effae; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000440efffff000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000003b; ++ *((unsigned long *)&__m128i_op11) = 0x0000440efffff000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000003b; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0xffff2356fe165486; ++ *((unsigned long *)&__m128i_op10) = 0x5efeb3165bd7653d; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff2356fe165486; ++ __m128i_out = __lsx_vpackod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000cecd00004657; ++ *((unsigned long *)&__m128i_op00) = 0x0000c90000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00019d9a00008cae; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vpackod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickev.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickev.c +new file mode 100644 +index 000000000..58591f1bb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickev.c +@@ -0,0 +1,362 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc2409edab019323f; ++ *((unsigned long *)&__m128i_op10) = 0x460f3b393ef4be3a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x460f3b393ef4be3a; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0004007c00fc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000fc0000; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vpickev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vpickev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xedfaedfaedfaedfa; ++ *((unsigned long *)&__m128i_op00) = 0xedfaedfaedfaedfa; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0xedfaedfaedfaedfa; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4811fda96793b23a; ++ *((unsigned long *)&__m128i_op00) = 0x8f10624016be82fd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xfda9b23a624082fd; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xaaaaffebcfb748e0; ++ *((unsigned long *)&__m128i_op10) = 0xfd293eab528e7ebe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0xffeb48e03eab7ebe; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff7; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result1) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result0) = 0xfffff00010000fff; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000120002000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x2000200000013fa0; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000013fa0; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000f7d1000000001; ++ *((unsigned long *)&__m128i_op00) = 0x773324887fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000017161515; ++ *((unsigned long *)&__m128i_op10) = 0x0000000095141311; ++ *((unsigned long *)&__m128i_result1) = 0x000000017fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x1716151595141311; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_result0) = 0x4040404040404040; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000dfa6e0c6; ++ *((unsigned long *)&__m128i_op00) = 0x00000000d46cdc13; ++ *((unsigned long *)&__m128i_op11) = 0x7ef400ad21fc7081; ++ *((unsigned long *)&__m128i_op10) = 0x28bf0351ec69b5f2; ++ *((unsigned long *)&__m128i_result1) = 0xdfa6e0c6d46cdc13; ++ *((unsigned long *)&__m128i_result0) = 0x21fc7081ec69b5f2; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x04c0044a0400043a; ++ *((unsigned long *)&__m128i_op00) = 0x04c004d6040004c6; ++ *((unsigned long *)&__m128i_op11) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op10) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result1) = 0x044a043a04d604c6; ++ *((unsigned long *)&__m128i_result0) = 0x0004000400040004; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001b4a00007808; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00001b4a00007808; ++ *((unsigned long *)&__m128i_result1) = 0x00001b4a00007808; ++ *((unsigned long *)&__m128i_result0) = 0x00001b4a00007808; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fc03fc000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7f801fe000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff00010001; ++ *((unsigned long *)&__m128i_op10) = 0x3fc03fc000000004; ++ *((unsigned long *)&__m128i_result1) = 0x7f801fe000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3fc03fc000000004; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffffffff; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000001000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffff00; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x000103030102ffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffff00ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000010102ffff; ++ __m128i_out = __lsx_vpickev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_op00) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x01533b5e7489ae24; ++ *((unsigned long *)&__m128i_op10) = 0xffffab7e71e33848; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x3b5eae24ab7e3848; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000009c83e21a; ++ *((unsigned long *)&__m128i_op00) = 0x0000000022001818; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000e21a00001818; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op10) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4f4f4f4f4f4f4f4f; ++ __m128i_out = __lsx_vpickev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickod.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickod.c +new file mode 100644 +index 000000000..74269e319 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickod.c +@@ -0,0 +1,336 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000401000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op10) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000401000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000001; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_op00) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xf436f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_result1) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf4b6f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_op11) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xf4b6f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_result1) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0080000000000000; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff51cf8da; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffd6040188; ++ *((unsigned long *)&__m128i_op11) = 0x0000101fffff8b68; ++ *((unsigned long *)&__m128i_op10) = 0x00000b6fffff8095; ++ *((unsigned long *)&__m128i_result1) = 0xfffff51cffffd604; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vpickod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0xa); ++ *((unsigned long *)&__m128i_op01) = 0xffffff0cffffff18; ++ *((unsigned long *)&__m128i_op00) = 0xfefffefffeff6a0c; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xc2f9bafac2fac2fa; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffefefe6a; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c2bac2c2; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_op10) = 0x0f000d200e000c20; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x11000f200f000d20; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000805; ++ *((unsigned long *)&__m128i_op00) = 0x978d95ac768d8784; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000104000800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000897957687; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000408; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ff91fffffff5; ++ *((unsigned long *)&__m128i_op00) = 0xffff00650001ffb0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffff0001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ca02f854; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ca02f854; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ca0200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ca0200000000; ++ __m128i_out = __lsx_vpickod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000c6c6ee22; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c6c62e8a; ++ *((unsigned long *)&__m128i_op11) = 0x00000000c6c6ee22; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c6c62e8a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e1d001b1a; ++ *((unsigned long *)&__m128i_op00) = 0x1918171615141312; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x21201f1e19181716; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff000000ff; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0006000000040000; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x6363636363636363; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f801fe000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3fc03fc000000004; ++ *((unsigned long *)&__m128i_op11) = 0x3fc03fc000000003; ++ *((unsigned long *)&__m128i_op10) = 0x7f7f1fd800000004; ++ *((unsigned long *)&__m128i_result1) = 0x7f1f00003f3f0000; ++ *((unsigned long *)&__m128i_result0) = 0x3f3f00007f1f0000; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff9f017f1fa0b199; ++ *((unsigned long *)&__m128i_op00) = 0x1197817fd839ea3e; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000033; ++ *((unsigned long *)&__m128i_result1) = 0xff011fb11181d8ea; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080808000; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fffefffe; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_result1) = 0x67ebb2ebc884ed3f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000003ddc; ++ __m128i_out = __lsx_vpickod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000003e2; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000003e2; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128i_op10) = 0x00012c8a0000a58a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010000; ++ __m128i_out = __lsx_vpickod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpickod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickve2gr.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickve2gr.c +new file mode 100644 +index 000000000..acca2bee9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpickve2gr.c +@@ -0,0 +1,488 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x7); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0x4); ++ int_result = 0x0000000000000000; ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lsx_vpickve2gr_d (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x01fc020000fe0100; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x7); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000463fd2902d; ++ *((unsigned long *)&__m128i_op00) = 0x5ccd54bbfcac806c; ++ unsigned_int_result = 0x00000000000000ac; ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x697eba2bedfa9c82; ++ *((unsigned long *)&__m128i_op00) = 0xd705c77a7025c899; ++ unsigned_int_result = 0x000000000000edfa; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_op00) = 0x0400040004000400; ++ unsigned_int_result = 0x0000000000000400; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000007d3ac600; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0x7); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dffbfff00000001; ++ *((unsigned long *)&__m128i_op00) = 0x0200400000000001; ++ unsigned_int_result = 0x0000000000000001; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000003fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x000000003fffffff; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000490000004d; ++ *((unsigned long *)&__m128i_op00) = 0x00000001ffffffff; ++ long_int_result = 0x00000001ffffffff; ++ long_int_out = __lsx_vpickve2gr_d (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_op00) = 0x00a6ffceffb60052; ++ unsigned_int_result = 0x0000000000000084; ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0xa); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lsx_vpickve2gr_d (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ int_result = 0x00000000ffffffff; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xc); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ unsigned_int_result = 0x00000000ffffffff; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ long_int_result = 0xffffffffffffffff; ++ long_int_out = __lsx_vpickve2gr_d (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lsx_vpickve2gr_d (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op00) = 0x3f8000003f800000; ++ unsigned_long_int_result = 0x3f8000003f800000; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0bd80bd80bd80bd8; ++ *((unsigned long *)&__m128i_op00) = 0x0bd80bd80bd80bd8; ++ unsigned_long_int_result = 0x0bd80bd80bd80bd8; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0x8); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000c0000bd49; ++ *((unsigned long *)&__m128i_op00) = 0x0000000c7fff000c; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xb); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000100c6ffef10c; ++ unsigned_int_result = 0x00000000000000ff; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x2020202020207f7f; ++ unsigned_int_result = 0x0000000020202020; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_op00) = 0x003dbe88077c78c1; ++ int_result = 0x0000000000003a24; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000ffffffff; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ unsigned_int_result = 0x00000000000000ff; ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0x9); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0xb); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffe080f6efc100f7; ++ *((unsigned long *)&__m128i_op00) = 0xefd32176ffe100f7; ++ int_result = 0x0000000000002176; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ long_int_result = 0x0000000000000000; ++ long_int_out = __lsx_vpickve2gr_d (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ int_result = 0x0000000000000002; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80008000ec82ab51; ++ *((unsigned long *)&__m128i_op00) = 0x8000800089e08000; ++ int_result = 0x0000000089e08000; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000ffffffff; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6453f5e01d6e5000; ++ *((unsigned long *)&__m128i_op00) = 0x000fdec000000000; ++ int_result = 0x000000001d6e5000; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6453f5e01d6e5000; ++ *((unsigned long *)&__m128i_op00) = 0x000fdec000000000; ++ int_result = 0x0000000001d6e5000; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xe); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000ffffffff; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8d78336c83652b86; ++ *((unsigned long *)&__m128i_op00) = 0x39c51f389c0d6112; ++ int_result = 0x000000009c0d6112; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op00) = 0x05fafe0101fe000e; ++ unsigned_int_result = 0x000000000000857a; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x021b7d2449678a35; ++ *((unsigned long *)&__m128i_op00) = 0x030298a621030a49; ++ int_result = 0x00000000ffff8a35; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op00) = 0x001effae001effae; ++ unsigned_int_result = 0x000000000000001e; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xe); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000ffffffff; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8d78336c83652b86; ++ *((unsigned long *)&__m128i_op00) = 0x39c51f389c0d6112; ++ int_result = 0x000000009c0d6112; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op00) = 0x05fafe0101fe000e; ++ unsigned_int_result = 0x000000000000857a; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x021b7d2449678a35; ++ *((unsigned long *)&__m128i_op00) = 0x030298a621030a49; ++ int_result = 0x00000000ffff8a35; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op00) = 0x001effae001effae; ++ unsigned_int_result = 0x000000000000001e; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0x8); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x000000000000001e; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_int_result = 0x0000000000000000; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x5); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003ddc5dac; ++ long_int_result = 0x000000003ddc5dac; ++ long_int_out = __lsx_vpickve2gr_d (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, long_int_result, long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6453f5e01d6e5000; ++ *((unsigned long *)&__m128i_op00) = 0x000fdec000000000; ++ int_result = 0x000000001d6e5000; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xe); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ int_result = 0x00000000ffffffff; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8d78336c83652b86; ++ *((unsigned long *)&__m128i_op00) = 0x39c51f389c0d6112; ++ int_result = 0x000000009c0d6112; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op00) = 0x05fafe0101fe000e; ++ unsigned_int_result = 0x000000000000857a; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x1); ++ ASSERTEQ_int (__LINE__, int_out, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x021b7d2449678a35; ++ *((unsigned long *)&__m128i_op00) = 0x030298a621030a49; ++ int_result = 0x00000000ffff8a35; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x4); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op00) = 0x001effae001effae; ++ unsigned_int_result = 0x000000000000001e; ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0674c8868a74fc80; ++ *((unsigned long *)&__m128i_op00) = 0xfdce8003090b0906; ++ int_result = 0x00000000090b0906; ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_result = 0x0000000000000000; ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x3); ++ ASSERTEQ_int (__LINE__, int_result, int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000feff23560000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fd1654860000; ++ unsigned_int_result = 0x00000000000000ff; ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0xc); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ unsigned_long_int_result = 0x0000000000000000; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f4f00004f4f0000; ++ *((unsigned long *)&__m128i_op00) = 0x4f4f00004f4f0000; ++ unsigned_int_result = 0x000000004f4f0000; ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_int_result, unsigned_int_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000120000000d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000e0000000e; ++ unsigned_long_int_result = 0x0000000e0000000e; ++ unsigned_long_int_out = __lsx_vpickve2gr_du (__m128i_op0, 0x0); ++ ASSERTEQ_int (__LINE__, unsigned_long_int_result, unsigned_long_int_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpremi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpremi.c +new file mode 100644 +index 000000000..ef0ad676e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpremi.c +@@ -0,0 +1,20 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplgr2vr.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplgr2vr.c +new file mode 100644 +index 000000000..a5f02b1b1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplgr2vr.c +@@ -0,0 +1,212 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ int_op0 = 0x0000000059815d00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x0400040004000400; ++ __m128i_out = __lsx_vreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ long_op0 = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000400; ++ __m128i_out = __lsx_vreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ long_op0 = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result1) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result0) = 0x3f8000003f800000; ++ __m128i_out = __lsx_vreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000020202020; ++ *((unsigned long *)&__m128i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_result0) = 0x2020202020202020; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff000000ff; ++ __m128i_out = __lsx_vreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ long_op0 = 0x000000007ff00000; ++ *((unsigned long *)&__m128i_result1) = 0x000000007ff00000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007ff00000; ++ __m128i_out = __lsx_vreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ long_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_d (long_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x000000000000001e; ++ *((unsigned long *)&__m128i_result1) = 0x1e1e1e1e1e1e1e1e; ++ *((unsigned long *)&__m128i_result0) = 0x1e1e1e1e1e1e1e1e; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_w (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_h (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_op0 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplgr2vr_b (int_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplve.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplve.c +new file mode 100644 +index 000000000..463adb48e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplve.c +@@ -0,0 +1,300 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000045eef14fe8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000000000ac; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_d (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x78c00000ff000000; ++ int_op1 = 0x0000000000000400; ++ *((unsigned long *)&__m128i_result1) = 0xff000000ff000000; ++ *((unsigned long *)&__m128i_result0) = 0xff000000ff000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x803f800080000000; ++ *((unsigned long *)&__m128i_op00) = 0xe0404041c0404040; ++ int_op1 = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128i_result0) = 0xe0404041e0404041; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffffffff0001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_h (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ int_op1 = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000020006; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_h (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffb4ff; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffb4ff; ++ __m128i_out = __lsx_vreplve_d (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000020202020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_d (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x000000007ff00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_d (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000020006; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_h (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff4; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffff00ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0x00ffff00ff00ff00; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0xff00ff00ff00ff00; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ int_op1 = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000001b; ++ int_op1 = 0xffffffff89e08000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001b0000001b; ++ *((unsigned long *)&__m128i_result0) = 0x0000001b0000001b; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_h (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefefefdbffefdfe; ++ *((unsigned long *)&__m128i_op00) = 0xfefefeeffef7fefe; ++ int_op1 = 0xffffffff9c0d6112; ++ *((unsigned long *)&__m128i_result1) = 0xbffefdfebffefdfe; ++ *((unsigned long *)&__m128i_result0) = 0xbffefdfebffefdfe; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xff800000ff800000; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result0) = 0xff800000ff800000; ++ __m128i_out = __lsx_vreplve_w (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0xffd27db010d20fbf; ++ int_op1 = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result1) = 0x0fbf0fbf0fbf0fbf; ++ *((unsigned long *)&__m128i_result0) = 0x0fbf0fbf0fbf0fbf; ++ __m128i_out = __lsx_vreplve_h (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0x00000000090b0906; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_b (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ int_op1 = 0xffffffffffff8a35; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplve_d (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x05dfffc3ffffffc0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000047fe2f0; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000047fe2f0; ++ *((unsigned long *)&__m128i_result0) = 0x00000000047fe2f0; ++ __m128i_out = __lsx_vreplve_d (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffe011df03e; ++ int_op1 = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xf03ef03ef03ef03e; ++ *((unsigned long *)&__m128i_result0) = 0xf03ef03ef03ef03e; ++ __m128i_out = __lsx_vreplve_h (__m128i_op0, int_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplvei.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplvei.c +new file mode 100644 +index 000000000..a81be76f1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vreplvei.c +@@ -0,0 +1,293 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000055555501; ++ *((unsigned long *)&__m128i_op00) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_result1) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_result0) = 0x0000005555555554; ++ __m128i_out = __lsx_vreplvei_d (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000036280000; ++ *((unsigned long *)&__m128i_op00) = 0x42a0000042a02000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x697eba2bedfa9c82; ++ *((unsigned long *)&__m128i_op00) = 0xd705c77a7025c899; ++ *((unsigned long *)&__m128i_result1) = 0xedfaedfaedfaedfa; ++ *((unsigned long *)&__m128i_result0) = 0xedfaedfaedfaedfa; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000300000003; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000a0a08000; ++ *((unsigned long *)&__m128i_op00) = 0x5350a08000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_result0) = 0x8000800080008000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80010009816ac5de; ++ *((unsigned long *)&__m128i_op00) = 0x8001000184000bd8; ++ *((unsigned long *)&__m128i_result1) = 0x0bd80bd80bd80bd8; ++ *((unsigned long *)&__m128i_result0) = 0x0bd80bd80bd80bd8; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_b (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_b (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_d (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x1149a96eb1a08000; ++ *((unsigned long *)&__m128i_result1) = 0xb1a08000b1a08000; ++ *((unsigned long *)&__m128i_result0) = 0xb1a08000b1a08000; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_d (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffcc9a989a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_b (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_op00) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_result1) = 0xadadadadadadadad; ++ *((unsigned long *)&__m128i_result0) = 0xadadadadadadadad; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_d (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplvei_b (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3131313131313131; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_d (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_op00) = 0x0a753500a9fa0d06; ++ *((unsigned long *)&__m128i_result1) = 0x0d060d060d060d06; ++ *((unsigned long *)&__m128i_result0) = 0x0d060d060d060d06; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_b (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vreplvei_w (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vreplvei_h (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf.c +new file mode 100644 +index 000000000..4e7fcc02b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf.c +@@ -0,0 +1,394 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000007f00000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000401000001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100000004; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00000000007f0000; ++ *((unsigned long *)&__m128i_result1) = 0x0404040404040404; ++ *((unsigned long *)&__m128i_result0) = 0x0404040404000404; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000002f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000029; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op21) = 0x000000000000002f; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000029; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff00; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7efefefe82010201; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x418181017dfefdff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff81; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_op10) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_op21) = 0x800000007fffffff; ++ *((unsigned long *)&__m128i_op20) = 0x800000007fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00adadad00000000; ++ *((unsigned long *)&__m128i_result0) = 0x00adadad00000000; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_op10) = 0xc5c534920000c4ed; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xedededededededed; ++ *((unsigned long *)&__m128i_result0) = 0xedededededededed; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op11) = 0x04040403fafafafc; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ff80; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op21) = 0x0000001a0000000b; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x00000080000000ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff6cffb5ff98ff6e; ++ *((unsigned long *)&__m128i_op00) = 0xffd7ff8dffa4ff7a; ++ *((unsigned long *)&__m128i_op11) = 0x34947b4b11684f92; ++ *((unsigned long *)&__m128i_op10) = 0xee297a731e5c5f86; ++ *((unsigned long *)&__m128i_op21) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffc0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000868686868686; ++ __m128i_out = __lsx_vshuf_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_result1) = 0x000d000d000d000d; ++ *((unsigned long *)&__m128i_result0) = 0x000d000d000d000d; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128i_op21) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000300037ff000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0003000300a10003; ++ *((unsigned long *)&__m128i_op11) = 0x000300037ff000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0003000300a10003; ++ *((unsigned long *)&__m128i_op21) = 0x000000007ff000ff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0909000009090000; ++ *((unsigned long *)&__m128i_op00) = 0x0909000009090000; ++ *((unsigned long *)&__m128i_op11) = 0x0909000009090000; ++ *((unsigned long *)&__m128i_op10) = 0x0909000009090000; ++ *((unsigned long *)&__m128i_op21) = 0x002a05a2f059094a; ++ *((unsigned long *)&__m128i_op20) = 0x05ad3ba576eae048; ++ *((unsigned long *)&__m128i_result1) = 0x0909e0480909e048; ++ *((unsigned long *)&__m128i_result0) = 0x0909e0480909e048; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000000c0; ++ *((unsigned long *)&__m128i_op00) = 0x00000001ffffff29; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x00000000000000c0; ++ *((unsigned long *)&__m128i_op20) = 0x00000001ffffff29; ++ *((unsigned long *)&__m128i_result1) = 0xffffff2900000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1f54e0ab00000000; ++ *((unsigned long *)&__m128i_op21) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op20) = 0x010101fe0101fe87; ++ *((unsigned long *)&__m128i_result1) = 0x0101fe870101fe87; ++ *((unsigned long *)&__m128i_result0) = 0x0101fe8700000000; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_op20) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_result1) = 0x2000002000000000; ++ *((unsigned long *)&__m128i_result0) = 0x2000002020000020; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000004870ba0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op21) = 0x8000000100000000; ++ *((unsigned long *)&__m128i_op20) = 0x8000000000000103; ++ *((unsigned long *)&__m128i_result1) = 0x0000010300000103; ++ *((unsigned long *)&__m128i_result0) = 0x0000010300000000; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op00) = 0x05fafe0101fe000e; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xada4808924882588; ++ *((unsigned long *)&__m128i_op00) = 0xacad25090caca5a4; ++ *((unsigned long *)&__m128i_op11) = 0x021b7d24c9678a35; ++ *((unsigned long *)&__m128i_op10) = 0x030298a6a1030a49; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xdfa6e0c6d46cdc13; ++ *((unsigned long *)&__m128i_op00) = 0x21fc7081ec69b5f2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000002c002400; ++ *((unsigned long *)&__m128i_op21) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_op20) = 0xffff6080ffff4417; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff0015172b; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff0015172b; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff0015172b; ++ __m128i_out = __lsx_vshuf_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op10) = 0xf0003000f0003000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x021b7d2449678a35; ++ *((unsigned long *)&__m128i_op00) = 0x030298a621030a49; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op21) = 0x021b7d24c9678a35; ++ *((unsigned long *)&__m128i_op20) = 0x030298a6a1030a49; ++ *((unsigned long *)&__m128i_result1) = 0x021b7d24c9678a35; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f7f00007f7f0000; ++ *((unsigned long *)&__m128i_op00) = 0x7f7f80807f7f8080; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000fffe0000fffe; ++ *((unsigned long *)&__m128i_op21) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op20) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result1) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffff10000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf4i.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf4i.c +new file mode 100644 +index 000000000..cd441b841 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vshuf4i.c +@@ -0,0 +1,348 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000030000; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0xc9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0004007c00fc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x047c0404fc00fcfc; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x8a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff00ff7f00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x85); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff51cf8da; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffd6040188; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff01018888; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x50); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007d00c50177ac5b; ++ *((unsigned long *)&__m128i_op00) = 0xac82aa88a972a36a; ++ *((unsigned long *)&__m128i_result1) = 0x000000c5ac01015b; ++ *((unsigned long *)&__m128i_result0) = 0xaaacac88a3a9a96a; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x7c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000a0000000a; ++ *((unsigned long *)&__m128i_op00) = 0x0000000a00000009; ++ *((unsigned long *)&__m128i_result1) = 0x0a0a0a000a0a0a00; ++ *((unsigned long *)&__m128i_result0) = 0x0a0a0a0009090900; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000100; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00003f8000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00003f8000000000; ++ *((unsigned long *)&__m128i_result1) = 0x003f800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x003f800000000000; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0xd2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x6c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x81); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000dffff000d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ffffff; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x6b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5f675e96e29a5a60; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x965f5e9660e25a60; ++ *((unsigned long *)&__m128i_result0) = 0xff7f7fffff7f7fff; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x34); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x131211101211100f; ++ *((unsigned long *)&__m128i_op00) = 0x11100f0e100f0e0d; ++ *((unsigned long *)&__m128i_result1) = 0x13101213120f1112; ++ *((unsigned long *)&__m128i_result0) = 0x110e1011100d0f10; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0xcb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000110; ++ *((unsigned long *)&__m128i_op00) = 0x00000000431f851f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001011010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000043431f1f; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0xf0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op00) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_result1) = 0xd1c0c0a5baf8f8d3; ++ *((unsigned long *)&__m128i_result0) = 0xecbbbbc5d5f3f3f3; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0x7c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op00) = 0x00000454ffff9573; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result0) = 0x00000454ffff9573; ++ __m128i_out = __lsx_vshuf4i_b (__m128i_op0, 0xa4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0xf3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0xd2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x007c000d00400000; ++ *((unsigned long *)&__m128i_result1) = 0x0000003f00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000007c00000040; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0x31); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0xb9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff00007fff0000; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0xcd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff00000000ffff; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0x93); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000007f7f7f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007f007f00007f7f; ++ __m128i_out = __lsx_vshuf4i_h (__m128i_op0, 0x58); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080808000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080808000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x8b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_op00) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_result1) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_result0) = 0xfffdfffdfffdfffd; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x7e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefefefdbffefdfe; ++ *((unsigned long *)&__m128i_op00) = 0xfefefeeffef7fefe; ++ *((unsigned long *)&__m128i_result1) = 0xfef7fefebffefdfe; ++ *((unsigned long *)&__m128i_result0) = 0xfefefefdfefefeef; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x002a001a001a000b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000002a001a; ++ *((unsigned long *)&__m128i_result0) = 0x001a000b00000000; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x78); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x98); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000010f8000081a2; ++ *((unsigned long *)&__m128i_op00) = 0x000069bb00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x00000001000010f8; ++ __m128i_out = __lsx_vshuf4i_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0x44); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffff800; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fffff800; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fffff800; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0x8a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0x36); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffda6e; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffe3d6; ++ *((unsigned long *)&__m128i_op11) = 0xeeb1e4f4bc3763f3; ++ *((unsigned long *)&__m128i_op10) = 0x6f5edf5ada6fe3d7; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffe3d6; ++ *((unsigned long *)&__m128i_result0) = 0xeeb1e4f4bc3763f3; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100200001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100200001; ++ *((unsigned long *)&__m128i_op11) = 0x00001fff00001fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xce23d33e43d9736c; ++ *((unsigned long *)&__m128i_op10) = 0x63b2ac27aa076aeb; ++ *((unsigned long *)&__m128i_result1) = 0x63b2ac27aa076aeb; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0xc8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0xc9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0xbf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x801d5de0000559e0; ++ *((unsigned long *)&__m128i_op00) = 0x77eb86788eebaf00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x89582bf870006860; ++ *((unsigned long *)&__m128i_op10) = 0x89582bf870006860; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vshuf4i_d (__m128i_op0, __m128i_op1, 0x94); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-subtraction-instru.patch
Added
@@ -0,0 +1,4150 @@ +From dc800193eb03dc87e702d4f3aeb886337b6be870 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 10:05:37 +0800 +Subject: PATCH 081/124 LoongArch: Add tests for SX vector subtraction + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vhsubw-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vhsubw-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmsub.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssub-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssub-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsub.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsubi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsubwev-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsubwev-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsubwod-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsubwod-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vhsubw-1.c | 327 +++++++++++++ + .../loongarch/vector/lsx/lsx-vhsubw-2.c | 353 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vmsub.c | 461 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vssub-1.c | 398 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vssub-2.c | 408 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vsub.c | 381 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vsubi.c | 329 +++++++++++++ + .../loongarch/vector/lsx/lsx-vsubwev-1.c | 326 +++++++++++++ + .../loongarch/vector/lsx/lsx-vsubwev-2.c | 417 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vsubwod-1.c | 326 +++++++++++++ + .../loongarch/vector/lsx/lsx-vsubwod-2.c | 308 ++++++++++++ + 11 files changed, 4034 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsub.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsub.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-1.c +new file mode 100644 +index 000000000..0b51cb8cf +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-1.c +@@ -0,0 +1,327 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffffc00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010000; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00007f8000007f80; ++ *((unsigned long *)&__m128i_op10) = 0x00007f8000007f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000008000000080; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff07effffe; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100110002; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffff01; ++ *((unsigned long *)&__m128i_op00) = 0xffffeff400000df4; ++ *((unsigned long *)&__m128i_op11) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op10) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0x0000ff91fffffff5; ++ *((unsigned long *)&__m128i_result0) = 0xffff00650001ffb0; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000bfffffffe0f6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000010001000a; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x41dfffffffc00000; ++ *((unsigned long *)&__m128i_op00) = 0xbff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result1) = 0x0039ffffffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffbeffffffffffff; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000008140c80; ++ *((unsigned long *)&__m128i_result1) = 0x0037ffdfffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0037ffdfffeb007f; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_op00) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x4e3e133738bb47d2; ++ *((unsigned long *)&__m128i_result1) = 0xff98007a004d0050; ++ *((unsigned long *)&__m128i_result0) = 0xfff9ff4a0057000e; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000501ffff0005; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000600000001; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00020000ffff0001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100000001; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffae001effae; ++ *((unsigned long *)&__m128i_op00) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op11) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op10) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_result1) = 0xffaeffadffaeffad; ++ *((unsigned long *)&__m128i_result0) = 0xffaeffadffaeffad; ++ __m128i_out = __lsx_vhsubw_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000201000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000fc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000000; ++ __m128i_out = __lsx_vhsubw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffff02; ++ __m128i_out = __lsx_vhsubw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vhsubw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vhsubw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffff01; ++ __m128i_out = __lsx_vhsubw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9727b8499727b849; ++ *((unsigned long *)&__m128i_op00) = 0x12755900b653f081; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7d7f13fc7c7ffbf4; ++ *((unsigned long *)&__m128i_result1) = 0xffff9727ffff9727; ++ *((unsigned long *)&__m128i_result0) = 0xfffffe79ffffba5f; ++ __m128i_out = __lsx_vhsubw_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000100010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000100010; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vhsubw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000100c6ffef10c; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffff70; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff9001a47e; ++ __m128i_out = __lsx_vhsubw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000a6; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff59; ++ __m128i_out = __lsx_vhsubw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffc; ++ __m128i_out = __lsx_vhsubw_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x002affd600000001; ++ *((unsigned long *)&__m128i_op10) = 0xcbc2723a4f12a5f8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x343d8dc5b0ed5a08; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op10) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fffe00006aea; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000455555555; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000003fe0000141e; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffc01ffffebe2; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x67eb8590b2ebafe1; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x56a09e662ab46b31; ++ *((unsigned long *)&__m128i_op10) = 0xb4b8122ef4054bb3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4b47edd10bfab44d; ++ __m128i_out = __lsx_vhsubw_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-2.c +new file mode 100644 +index 000000000..26b51ee14 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vhsubw-2.c +@@ -0,0 +1,353 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op00) = 0xffffff0000010000; ++ *((unsigned long *)&__m128i_op11) = 0xfe00fe00fe00fd01; ++ *((unsigned long *)&__m128i_op10) = 0xfe00fffefe0100f6; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff0001ffffff0a; ++ __m128i_out = __lsx_vhsubw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000017161515; ++ *((unsigned long *)&__m128i_op00) = 0x0000000095141311; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x76f424887fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000170014; ++ *((unsigned long *)&__m128i_result0) = 0xff0cff78ff96ff14; ++ __m128i_out = __lsx_vhsubw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff7cffd6ffc700b0; ++ __m128i_out = __lsx_vhsubw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vhsubw_hu_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op10) = 0x7f80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff00000000; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m128i_result0) = 0xffff0001ffff0001; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_result0) = 0x0000010100000101; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefeff00fefeff00; ++ *((unsigned long *)&__m128i_op00) = 0xfefeff00fefeff00; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x00007e7e00007e7e; ++ *((unsigned long *)&__m128i_result0) = 0x00007e7e00007e7e; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa2e3a36363636363; ++ *((unsigned long *)&__m128i_op00) = 0xa2e3a36463636363; ++ *((unsigned long *)&__m128i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000a2e300006363; ++ *((unsigned long *)&__m128i_result0) = 0x0000a2e300006363; ++ __m128i_out = __lsx_vhsubw_wu_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op00) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000052527d7d; ++ *((unsigned long *)&__m128i_result0) = 0x0000000052527d7d; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000002400180004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000024; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op00) = 0xffffff0000010000; ++ *((unsigned long *)&__m128i_op11) = 0xabff54f1ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xa5f7458b000802ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fff7fc01; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000002; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000002; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128i_op00) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128i_op11) = 0xffff80008a7555aa; ++ *((unsigned long *)&__m128i_op10) = 0x0a7535006af05cf9; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff758aaa56; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffa9fb0d07; ++ __m128i_out = __lsx_vhsubw_du_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_op11) = 0x0f180000ffe00000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000001ca02f854; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000004b01; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffb4ff; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00001b4a00007808; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffe4b5ffff87f8; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fc03fc000000003; ++ *((unsigned long *)&__m128i_op00) = 0x7f7f1fd800000004; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x3fc03fc000000004; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc080800000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc080800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7efefefe82010201; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x418181017dfefdff; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x67eb85afb2ebb000; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xe593c8c4e593c8c4; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff8000010f78; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff7f0080ff7ef088; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000155; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000f0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffff10000; ++ __m128i_out = __lsx_vhsubw_qu_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsub.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsub.c +new file mode 100644 +index 000000000..47cf33cfd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsub.c +@@ -0,0 +1,461 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfeffffffffff0002; ++ *((unsigned long *)&__m128i_op21) = 0x54beed87bc3f2be1; ++ *((unsigned long *)&__m128i_op20) = 0x8024d8f6a494afcb; ++ *((unsigned long *)&__m128i_result1) = 0xa8beed87bc3f2be1; ++ *((unsigned long *)&__m128i_result0) = 0x0024d8f6a494006a; ++ __m128i_out = __lsx_vmsub_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000fc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x3); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001ffff0001ffff; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xfffffff0ffe04000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001fc0000; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000200010; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_op00) = 0x040004000400040d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x040004000400040d; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xb327b9363c99d32e; ++ *((unsigned long *)&__m128i_op00) = 0xa1e7b475d925730f; ++ *((unsigned long *)&__m128i_op11) = 0x00000000003f80b0; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_op21) = 0x00007f8000007f80; ++ *((unsigned long *)&__m128i_op20) = 0x00007f8000007f80; ++ *((unsigned long *)&__m128i_result1) = 0xb327b9363c992b2e; ++ *((unsigned long *)&__m128i_result0) = 0xa1e7b475d925730f; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffff800; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff000000ff0000; ++ __m128i_out = __lsx_vmsub_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op21) = 0x000000004c7f4c7f; ++ *((unsigned long *)&__m128i_op20) = 0xe0c0c0c0d1c7d1c6; ++ *((unsigned long *)&__m128i_result1) = 0x061006100613030c; ++ *((unsigned long *)&__m128i_result0) = 0x4d6814ef9c77ce46; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7ffe7ffe7ffe7ffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000f00; ++ *((unsigned long *)&__m128i_op20) = 0x00000000ffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000002bfd9461; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3727f00000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc7e01fcfe0000000; ++ *((unsigned long *)&__m128i_op11) = 0x3727112c00000000; ++ *((unsigned long *)&__m128i_op10) = 0x39201f7120000040; ++ *((unsigned long *)&__m128i_op21) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xe5b9012c00000000; ++ *((unsigned long *)&__m128i_result0) = 0xc7e01fcfe0000000; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000004; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffff0204; ++ *((unsigned long *)&__m128i_op11) = 0x0000442900007b4c; ++ *((unsigned long *)&__m128i_op10) = 0x0000e22b0000efa4; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000442800007b50; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0204; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffefffffffe; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000002f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000029; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_op20) = 0x003dbe88077c78c1; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000002f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000029; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff0000007f800000; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_op10) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_result0) = 0x0fff0fff0fff0fff; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000003f0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffc3ffff003e; ++ *((unsigned long *)&__m128i_op21) = 0x0000003f0000ffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffc3ffff003e; ++ *((unsigned long *)&__m128i_result1) = 0x0000f07f0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffff177fffff0fc; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffbfffefffc9510; ++ *((unsigned long *)&__m128i_op00) = 0xfffbfffefffc9510; ++ *((unsigned long *)&__m128i_op11) = 0x0c0b0a090b0a0908; ++ *((unsigned long *)&__m128i_op10) = 0x0a09080709080706; ++ *((unsigned long *)&__m128i_op21) = 0xfffbfffefffc9510; ++ *((unsigned long *)&__m128i_op20) = 0xfffbfffefffc9510; ++ *((unsigned long *)&__m128i_result1) = 0x29c251319c3a5c90; ++ *((unsigned long *)&__m128i_result0) = 0x62fb9272df7da6b0; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8f8f8f8f8f8f8f8f; ++ *((unsigned long *)&__m128i_op10) = 0x8f8f8f8f8f8f8f8f; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x800000007fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x800000007fffffff; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000000; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001400000014; ++ *((unsigned long *)&__m128i_op00) = 0x0000001400000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000053a4f452; ++ *((unsigned long *)&__m128i_result1) = 0x0000001400000014; ++ *((unsigned long *)&__m128i_result0) = 0x0000001400000000; ++ __m128i_out = __lsx_vmsub_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00680486ffffffda; ++ *((unsigned long *)&__m128i_op00) = 0xffff913bfffffffd; ++ *((unsigned long *)&__m128i_op11) = 0x00680486ffffffda; ++ *((unsigned long *)&__m128i_op10) = 0xffff913bfffffffd; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_result1) = 0x00680486ffffffda; ++ *((unsigned long *)&__m128i_result0) = 0xffff913bb9951901; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op20) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0021b761002c593c; ++ *((unsigned long *)&__m128i_op00) = 0x002584710016cc56; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000001e03; ++ *((unsigned long *)&__m128i_result1) = 0x0021b761002c593c; ++ *((unsigned long *)&__m128i_result0) = 0x002584710016ea59; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000290; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000290; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0002000400000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0003000500000001; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001700000017; ++ *((unsigned long *)&__m128i_op00) = 0x59f7fd8759f7fd87; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffae001effae; ++ *((unsigned long *)&__m128i_op10) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op21) = 0x0000001700000017; ++ *((unsigned long *)&__m128i_op20) = 0x59f7fd8759f7fd87; ++ *((unsigned long *)&__m128i_result1) = 0xfd200ed2fd370775; ++ *((unsigned long *)&__m128i_result0) = 0x96198318780e32c5; ++ __m128i_out = __lsx_vmsub_d (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op00) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result0) = 0x0004000400040004; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128i_op20) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsub_w (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-1.c +new file mode 100644 +index 000000000..fc4cbb4e5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-1.c +@@ -0,0 +1,398 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001801f0307f80; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00001801f0307f80; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff01018888; ++ *((unsigned long *)&__m128i_result1) = 0x0101010108082626; ++ *((unsigned long *)&__m128i_result0) = 0x01010101ffff7878; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00fe000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfe80000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x027e0000000000ff; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffff98dea; ++ *((unsigned long *)&__m128i_op11) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x40f3fa0000000000; ++ *((unsigned long *)&__m128i_result1) = 0xc00fffffffffb4ff; ++ *((unsigned long *)&__m128i_result0) = 0xbf0c05fffff98dea; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000002f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000029; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x010101010101012f; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010129; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op11) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_op10) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_result1) = 0x1202120212021202; ++ *((unsigned long *)&__m128i_result0) = 0x1202120212021202; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_op10) = 0x41957fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0xbf6b810181018101; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff8ffa2fffdffb0; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0x0108015e01030150; ++ *((unsigned long *)&__m128i_result0) = 0x00000000017f0000; ++ __m128i_out = __lsx_vssub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf436f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_op11) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xf4b6f3f52f4ef4a8; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000101fd01fe; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_op10) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_result1) = 0xffc0ffc0ffc0ffc0; ++ *((unsigned long *)&__m128i_result0) = 0xffc0ffc0ffc0ffc0; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_op11) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x7fc0010181020103; ++ *((unsigned long *)&__m128i_result0) = 0x7fc0ffff81020103; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001e03; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000011e04; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363abdf16; ++ *((unsigned long *)&__m128i_op00) = 0x41f8e08016161198; ++ *((unsigned long *)&__m128i_op11) = 0x00000000246d9755; ++ *((unsigned long *)&__m128i_op10) = 0x000000002427c2ee; ++ *((unsigned long *)&__m128i_result1) = 0x636363633f3e47c1; ++ *((unsigned long *)&__m128i_result0) = 0x41f8e080f1ef4eaa; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001fffe00014b41; ++ *((unsigned long *)&__m128i_op10) = 0x0001fffe0001ffde; ++ *((unsigned long *)&__m128i_result1) = 0xffff0002ffffb4bf; ++ *((unsigned long *)&__m128i_result0) = 0xffff0002ffff0022; ++ __m128i_out = __lsx_vssub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001fc0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000002010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001fbdff0; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x03f1e3d28b1a8a1a; ++ *((unsigned long *)&__m128i_op11) = 0x000000000001d5d4; ++ *((unsigned long *)&__m128i_op10) = 0x000000150d707009; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fffe2a2c; ++ *((unsigned long *)&__m128i_result0) = 0x03f1e3bd80000000; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffd5002affffffff; ++ *((unsigned long *)&__m128i_op10) = 0x343d8dc6b0ed5a08; ++ *((unsigned long *)&__m128i_result1) = 0x002affd600000001; ++ *((unsigned long *)&__m128i_result0) = 0xcbc2723a4f12a5f8; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffffffe; ++ *((unsigned long *)&__m128i_op11) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result1) = 0xffffffdfffffffe0; ++ *((unsigned long *)&__m128i_result0) = 0xffffffdfffffffe0; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000c2f90000bafa; ++ *((unsigned long *)&__m128i_op11) = 0x0000c2f90000bafa; ++ *((unsigned long *)&__m128i_op10) = 0x8000c2fa8000c2fa; ++ *((unsigned long *)&__m128i_result1) = 0xffff3d06ffff4506; ++ *((unsigned long *)&__m128i_result0) = 0x7ffffffe7ffff800; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m128i_op00) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff3fffffff4; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff3fffffff4; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ef8000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8108000000000000; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000063b2ac27; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffaa076aeb; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op10) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff63b3584e; ++ *((unsigned long *)&__m128i_result0) = 0x0000fffdaa07d5d6; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff81; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff7c; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff7cffd6ffc700b0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x008300290038ff50; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c0dec4d1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff3f213b2f; ++ __m128i_out = __lsx_vssub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-2.c +new file mode 100644 +index 000000000..0d5987567 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssub-2.c +@@ -0,0 +1,408 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f801fa06451ef11; ++ *((unsigned long *)&__m128i_op00) = 0x68bcf93435ed25ed; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffb64c; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000003900; ++ *((unsigned long *)&__m128i_result0) = 0x68bcf93435ed25ed; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x460f3b393ef4be3a; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x04e00060ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x04e00060ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x04e00060ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x04e00060ffffffff; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_op00) = 0x004200a000200001; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000001c; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000001c; ++ *((unsigned long *)&__m128i_result1) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_result0) = 0x004200a000200000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0c03e17edd781b11; ++ *((unsigned long *)&__m128i_op00) = 0x342caf9be5579ebe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000f909; ++ *((unsigned long *)&__m128i_result1) = 0x0c03e17edd781b11; ++ *((unsigned long *)&__m128i_result0) = 0x342caf9be55700b5; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_op00) = 0x0f000d200e000c20; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_result0) = 0x0f000d200e000c20; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_op00) = 0x000fffefffefffef; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_result0) = 0x000fffefffefffef; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x4e3e13368c17f6e6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111311111114111; ++ *((unsigned long *)&__m128i_op00) = 0x1111311111112111; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_result1) = 0x1111311111114111; ++ *((unsigned long *)&__m128i_result0) = 0x1111311111110000; ++ __m128i_out = __lsx_vssub_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_op11) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op10) = 0x0202fe02fd020102; ++ *((unsigned long *)&__m128i_result1) = 0xfefcfefcfefcfefc; ++ *((unsigned long *)&__m128i_result0) = 0xfcfc00fc01fcfdfc; ++ __m128i_out = __lsx_vssub_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00004000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_op00) = 0xc5c53492f25acbf2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_result1) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_result0) = 0xc5c534920000c4ed; ++ __m128i_out = __lsx_vssub_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op10) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff000000ff; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff000000000000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc14eef7fc14ea000; ++ *((unsigned long *)&__m128i_op10) = 0x000ea000010fa101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xb); ++ *((unsigned long *)&__m128i_op01) = 0x000000000000bd3d; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000c7fff000c; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000006ffef000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc2ffe700000007; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffc100010001; ++ *((unsigned long *)&__m128i_op11) = 0x41dfffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xbde2ffe800000007; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffc100010001; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xa000308000008002; ++ *((unsigned long *)&__m128i_op10) = 0x0500847b00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op10) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x006f0efe258ca851; ++ *((unsigned long *)&__m128i_op11) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op10) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0xffffff90ffffe0f5; ++ *((unsigned long *)&__m128i_result0) = 0x006e7973258d0ef4; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ca02f854; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000d0000000d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x6363635663636356; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssub_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsub.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsub.c +new file mode 100644 +index 000000000..f5c82bc74 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsub.c +@@ -0,0 +1,381 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ff02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000001fe; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op00) = 0xc6ffe000c6fde000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808081; ++ *((unsigned long *)&__m128i_result1) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_result0) = 0x467f6080467d607f; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00fe00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00fe00fe00ff; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op00) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff00007fff0000; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c0dec4d1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000040223c2e; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfd200ed2fd370775; ++ *((unsigned long *)&__m128i_op00) = 0x96198318780e32c5; ++ *((unsigned long *)&__m128i_op11) = 0xffffe65ecc1be5bc; ++ *((unsigned long *)&__m128i_op10) = 0xffffe65ecc1be5bc; ++ *((unsigned long *)&__m128i_result1) = 0xfe212874311c22b9; ++ *((unsigned long *)&__m128i_result0) = 0x971a9dbaacf34d09; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x0); ++ *((unsigned long *)&__m128i_op01) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op00) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result0) = 0x4f4f4f4f4f4f4f4f; ++ __m128i_out = __lsx_vsub_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op00) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op11) = 0xf000e001bf84df83; ++ *((unsigned long *)&__m128i_op10) = 0xfff8e001ff84e703; ++ *((unsigned long *)&__m128i_result1) = 0x14042382c3ffa481; ++ *((unsigned long *)&__m128i_result0) = 0x040c238283ff9d01; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_op10) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_result1) = 0xfebffefffebffeff; ++ *((unsigned long *)&__m128i_result0) = 0xfebffefffebffeff; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_op00) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_result0) = 0x1111111111111111; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op11) = 0x000700000004fdff; ++ *((unsigned long *)&__m128i_op10) = 0x000300000000fdff; ++ *((unsigned long *)&__m128i_result1) = 0xfff7fffefffa01ff; ++ *((unsigned long *)&__m128i_result0) = 0xfffbfffefffe01ff; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000000010000; ++ *((unsigned long *)&__m128i_op10) = 0x0000cd630000cd63; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0x0000329d0000329d; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x08080807f7f7f7f8; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result1) = 0x08080805f5f5f5f8; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff00; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00060eb000000006; ++ *((unsigned long *)&__m128i_op10) = 0x0000075c00000cf0; ++ *((unsigned long *)&__m128i_result1) = 0xfffaf1500000fffa; ++ *((unsigned long *)&__m128i_result0) = 0x0000f8a40000f310; ++ __m128i_out = __lsx_vsub_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff100fffc; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffdf100fffc; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000007f7f7f7f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x000000007f7f7f7f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000010; ++ __m128i_out = __lsx_vsub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000000000; ++ __m128i_out = __lsx_vsub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001802041b0013; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x00001802041b0014; ++ __m128i_out = __lsx_vsub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000f7d1000000001; ++ *((unsigned long *)&__m128i_op10) = 0x773324887fffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfff082efffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x88cbdb7780000001; ++ __m128i_out = __lsx_vsub_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001f50000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffe0b0000; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000fffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0010000000000001; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000800080; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000800080; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000b; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffeb; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffeb; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000015; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007000000050000; ++ *((unsigned long *)&__m128i_op00) = 0x0003000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0001fffe0001fefc; ++ *((unsigned long *)&__m128i_result1) = 0x0006000100040001; ++ *((unsigned long *)&__m128i_result0) = 0x00010002ffff0105; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000003fffffffd; ++ *((unsigned long *)&__m128i_op00) = 0x00000003fffffffd; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000003fffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x00000003fffffffd; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000feff23560000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fd1654860000; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363abdf16; ++ *((unsigned long *)&__m128i_op10) = 0x41f8e08016161198; ++ *((unsigned long *)&__m128i_result1) = 0x9c9d9b9bbfaa20e9; ++ *((unsigned long *)&__m128i_result0) = 0xbe081c963e6fee68; ++ __m128i_out = __lsx_vsub_q (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubi.c +new file mode 100644 +index 000000000..37e0ccf4d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubi.c +@@ -0,0 +1,329 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff489b693120950; ++ *((unsigned long *)&__m128i_op00) = 0xfffc45a851c40c18; ++ *((unsigned long *)&__m128i_result1) = 0xe0d56a9774f3ea31; ++ *((unsigned long *)&__m128i_result0) = 0xe0dd268932a5edf9; ++ __m128i_out = __lsx_vsubi_bu (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffff88; ++ *((unsigned long *)&__m128i_result1) = 0xe5e5e5e5e5e5e5e5; ++ *((unsigned long *)&__m128i_result0) = 0xe5e5e5e5e4e4e46d; ++ __m128i_out = __lsx_vsubi_bu (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000897957687; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000408; ++ *((unsigned long *)&__m128i_result1) = 0xf7f7f7ff8e8c6d7e; ++ *((unsigned long *)&__m128i_result0) = 0xf7f7f7f7f7f7fbff; ++ __m128i_out = __lsx_vsubi_bu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x1); ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xe6e6e6e6e6e6e6e6; ++ *((unsigned long *)&__m128i_result0) = 0xe6e6e6e6e6e6e6e6; ++ __m128i_out = __lsx_vsubi_bu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m128i_result0) = 0xf8f8f8f8f8f8f8f8; ++ __m128i_out = __lsx_vsubi_bu (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x2e34594c3b000000; ++ *((unsigned long *)&__m128i_result1) = 0xe9e9e9e9e9e9e9e9; ++ *((unsigned long *)&__m128i_result0) = 0x171d423524e9e9e9; ++ __m128i_out = __lsx_vsubi_bu (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffe2ffe2ffe2ffe2; ++ *((unsigned long *)&__m128i_result0) = 0xffe2ffe2ffe2ffe2; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9795698585057dec; ++ *((unsigned long *)&__m128i_op00) = 0x87f82867431a1d08; ++ *((unsigned long *)&__m128i_result1) = 0x9780697084f07dd7; ++ *((unsigned long *)&__m128i_result0) = 0x87e3285243051cf3; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_result0) = 0xfffcfffcfffcfffc; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000101; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffcfffcfffc00fd; ++ *((unsigned long *)&__m128i_result0) = 0xfffcfffcfffcfffc; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x371fe00000000000; ++ *((unsigned long *)&__m128i_op00) = 0x371fe00000000000; ++ *((unsigned long *)&__m128i_result1) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_result0) = 0x370bdfecffecffec; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000040600000406; ++ *((unsigned long *)&__m128i_op00) = 0x020202020202fe02; ++ *((unsigned long *)&__m128i_result1) = 0xfff503fbfff503fb; ++ *((unsigned long *)&__m128i_result0) = 0x01f701f701f7fdf7; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_result0) = 0xfffdfffdfffdfffd; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x803e0000803e0000; ++ *((unsigned long *)&__m128i_op00) = 0x803e0000803e0000; ++ *((unsigned long *)&__m128i_result1) = 0x803bfffd803bfffd; ++ *((unsigned long *)&__m128i_result0) = 0x803bfffd803bfffd; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_result0) = 0xfffdfffdfffdfffd; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffedffedffedffed; ++ *((unsigned long *)&__m128i_result0) = 0xffedffedffedffed; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffe4ffe4ffe4ffe4; ++ *((unsigned long *)&__m128i_result0) = 0xffe4ffe4ffe4ffe4; ++ __m128i_out = __lsx_vsubi_hu (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_result0) = 0xffffffefffffffef; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffe6ffffffe6; ++ *((unsigned long *)&__m128i_result0) = 0xffffffe6ffffffe6; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff1fffffff1; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff6fffffff6; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff6fffffff6; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffe4ffffffe4; ++ *((unsigned long *)&__m128i_result0) = 0xffffffe4ffffffe4; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffe1ffffffe1; ++ *((unsigned long *)&__m128i_result0) = 0xffffffe1ffffffe1; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff1fffffff1; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff1fffffff1; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffab7e71e33848; ++ *((unsigned long *)&__m128i_result1) = 0xffffffe1ffffffe1; ++ *((unsigned long *)&__m128i_result0) = 0xffffab5f71e33829; ++ __m128i_out = __lsx_vsubi_wu (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa8beed87bc3f2be1; ++ *((unsigned long *)&__m128i_op00) = 0x0024d8f6a494006a; ++ *((unsigned long *)&__m128i_result1) = 0xa8beed87bc3f2bd3; ++ *((unsigned long *)&__m128i_result0) = 0x0024d8f6a494005c; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffeb; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffeb; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffe1; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff7; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffe5; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf2f2e5e5e5e5e5e5; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xf2f2e5e5e5e5e5dc; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff7; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3ffffeffffffffe5; ++ *((unsigned long *)&__m128i_result0) = 0x3ffffeffffffffe5; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000070; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff5; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff0; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffe6; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffe6; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x000100010000fffb; ++ *((unsigned long *)&__m128i_result0) = 0x000100010000fffb; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffeb; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffeb; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffa; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffdfffe80008000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffe2; ++ *((unsigned long *)&__m128i_result0) = 0xfffdfffe80007fe2; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001a001a001a001a; ++ *((unsigned long *)&__m128i_op00) = 0x001a001a001a001a; ++ *((unsigned long *)&__m128i_result1) = 0x001a001a001a000b; ++ *((unsigned long *)&__m128i_result0) = 0x001a001a001a000b; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000234545b; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c0dec4d1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000002345454; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c0dec4ca; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0f8d33000f8d3300; ++ *((unsigned long *)&__m128i_op00) = 0x0003b80000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0f8d33000f8d32fd; ++ *((unsigned long *)&__m128i_result0) = 0x0003b7fffffffffd; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubi_du (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-1.c +new file mode 100644 +index 000000000..f0d391a09 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-1.c +@@ -0,0 +1,326 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128i_op00) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffd3000000130000; ++ *((unsigned long *)&__m128i_result0) = 0xffd3000000130000; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op00) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000100010000ffda; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000016; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffbfbfbfc0; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffbfbfbfc0; ++ *((unsigned long *)&__m128i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_result1) = 0xffbfffbfff7fff80; ++ *((unsigned long *)&__m128i_result0) = 0xffbfffbfff7fff80; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000808000020200; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff8000020000; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x413e276583869d79; ++ *((unsigned long *)&__m128i_op00) = 0x7f7f017f9d8726d3; ++ *((unsigned long *)&__m128i_op11) = 0x7c7cd2eb63637c52; ++ *((unsigned long *)&__m128i_op10) = 0x82ffd2210127add2; ++ *((unsigned long *)&__m128i_result1) = 0xffc2007aff230027; ++ *((unsigned long *)&__m128i_result0) = 0x0080005eff600001; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffee; ++ *((unsigned long *)&__m128i_op10) = 0x00000000011ff040; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010012; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffe1ffc0; ++ __m128i_out = __lsx_vsubwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000004000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffc000000000; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000d; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000ffff00; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000100c6ffef10c; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffff01; ++ *((unsigned long *)&__m128i_result0) = 0xffffeff400000df4; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_op00) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001c88bf0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000320; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000007730; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001030103; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000103; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x33eac9fdca42f660; ++ *((unsigned long *)&__m128i_op00) = 0xaa472d26fe867091; ++ *((unsigned long *)&__m128i_op11) = 0x33eac9fdca42f660; ++ *((unsigned long *)&__m128i_op10) = 0xaa472d26fe867091; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsubwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op00) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op11) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op10) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vsubwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op10) = 0x05fafe0101fe000e; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff7a86; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffe01fff2; ++ __m128i_out = __lsx_vsubwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf654ad7447e59090; ++ *((unsigned long *)&__m128i_op10) = 0x27b1b106b8145f50; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffb81a6f70; ++ *((unsigned long *)&__m128i_result0) = 0x0000000047eba0b0; ++ __m128i_out = __lsx_vsubwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000c01020d8009; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000003004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000c01020d5005; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffff01ff01; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4f804f804f804f80; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xb9fe3640e4eb1b18; ++ *((unsigned long *)&__m128i_op00) = 0x800000005b4b1b18; ++ *((unsigned long *)&__m128i_op11) = 0xffffb9fe00003640; ++ *((unsigned long *)&__m128i_op10) = 0xffffe4eb00001b18; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x80001b155b4b0000; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000008; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100080000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffefff80000; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x3fc03fc000000004; ++ *((unsigned long *)&__m128i_op11) = 0x3fc03fc000000003; ++ *((unsigned long *)&__m128i_op10) = 0x7f7f1fd800000004; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xc0411fe800000000; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128i_op00) = 0xff01e41ffff0e440; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xff01e420fff0e442; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-2.c +new file mode 100644 +index 000000000..3b18bc13c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwev-2.c +@@ -0,0 +1,417 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00ff00ff00000083; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0xff01ff010000ff7d; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000fffc; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0xffff00fc0000ff02; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xff01ff040000fffe; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op00) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_op11) = 0x21011f3f193d173b; ++ *((unsigned long *)&__m128i_op10) = 0xff39ff37ff35ff33; ++ *((unsigned long *)&__m128i_result1) = 0x00fe008e009e0071; ++ *((unsigned long *)&__m128i_result0) = 0x001c006f00c4008d; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9ca19d509ae734; ++ *((unsigned long *)&__m128i_op00) = 0xd1b09480f2123460; ++ *((unsigned long *)&__m128i_op11) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op10) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0x00000001fffeff98; ++ *((unsigned long *)&__m128i_result0) = 0x0014ffe4ff76ffc4; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x34947b4b11684f92; ++ *((unsigned long *)&__m128i_op10) = 0xee297a731e5c5f86; ++ *((unsigned long *)&__m128i_result1) = 0xff6cffb5ff98ff6e; ++ *((unsigned long *)&__m128i_result0) = 0xffd7ff8dffa4ff7a; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff01018888; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff3ea5016b; ++ *((unsigned long *)&__m128i_op10) = 0xfffefffe3f6fb04d; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000d96f; ++ *((unsigned long *)&__m128i_result0) = 0x00000001ffffd83b; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000f0009d3c; ++ *((unsigned long *)&__m128i_op00) = 0x000000016fff9d3d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000bd0; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000007f0; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000916c; ++ *((unsigned long *)&__m128i_result0) = 0x000000010000954d; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000100010000fe01; ++ *((unsigned long *)&__m128i_op11) = 0x000000050000007b; ++ *((unsigned long *)&__m128i_op10) = 0x0000000500000005; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffbffffff85; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffc0000fdfc; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000032; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000032; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff80df00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xa5c4c774856ba837; ++ *((unsigned long *)&__m128i_op10) = 0x2a569f8081c3bbe9; ++ *((unsigned long *)&__m128i_result1) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_result0) = 0xffff6080ffff4417; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000063b2ac27; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffaa076aeb; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_result0) = 0xffff0001ffff9515; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00060fbf00040fbf; ++ *((unsigned long *)&__m128i_op00) = 0x00020fbf00000fbf; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0xffffac5cffffac5c; ++ *((unsigned long *)&__m128i_result0) = 0xffffac5cffffac5c; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0xffaefffbffaefffb; ++ *((unsigned long *)&__m128i_op10) = 0xffaefffbffaefffb; ++ *((unsigned long *)&__m128i_result1) = 0xffff0005ffff0005; ++ *((unsigned long *)&__m128i_result0) = 0xffff000500000004; ++ __m128i_out = __lsx_vsubwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000a1630000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000a1630000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001fd0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000001fd0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff7ffffef77fffdd; ++ *((unsigned long *)&__m128i_op10) = 0xf77edf9cffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000008800022; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000001; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffda6f; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffe3d7; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffda6e; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffe3d6; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000807f00000000; ++ *((unsigned long *)&__m128i_op00) = 0x80006b0080808080; ++ *((unsigned long *)&__m128i_op11) = 0xffff00011cf0c569; ++ *((unsigned long *)&__m128i_op10) = 0xc0000002b0995850; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffe30f3a97; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffcfe72830; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ff9f5c25; ++ *((unsigned long *)&__m128i_op00) = 0x58fa6b4000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ff9f5c25; ++ *((unsigned long *)&__m128i_op10) = 0x58fa6b4000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xcda585aebbb2836a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080808080; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffc4cdfd16; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x801dd5cb0004e058; ++ *((unsigned long *)&__m128i_op00) = 0x77eb15638eeb5fc2; ++ *((unsigned long *)&__m128i_op11) = 0x000000200000001b; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000004e03d; ++ *((unsigned long *)&__m128i_result0) = 0x000000008eeb5fc2; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000c0000bd49; ++ *((unsigned long *)&__m128i_op00) = 0x0000000c7fff000c; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000100c6ffef00d; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000c00000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000bfffffffe0f6; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffcfffcfffcfffd; ++ *((unsigned long *)&__m128i_op00) = 0xfffcfffdfffcfffd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffcfffdfffcfffd; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff7e00000081; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0a0a0a0a0a0a0a0a; ++ *((unsigned long *)&__m128i_op00) = 0x0a0a0a0a0a0a0a0a; ++ *((unsigned long *)&__m128i_op11) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_op10) = 0xffff6080ffff4417; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0a0aa9890a0ac5f3; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op10) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x36fbdfdcffdcffdc; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffefffeffff; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_op10) = 0x0a753500a9fa0d06; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xf589caff5605f2fa; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x087c000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000087c; ++ *((unsigned long *)&__m128i_op11) = 0x10f8000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x00000001000010f8; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffefffff784; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0001000000000000; ++ __m128i_out = __lsx_vsubwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-1.c +new file mode 100644 +index 000000000..39ebff154 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-1.c +@@ -0,0 +1,326 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x40f3fa0000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xc485edbcc0000000; ++ *((unsigned long *)&__m128i_result1) = 0x003f000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007c000d00400000; ++ __m128i_out = __lsx_vsubwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x841f000fc28f801f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007c0000003e0080; ++ __m128i_out = __lsx_vsubwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vsubwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001001; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffff8000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffff8000000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffefefe6a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c2bac2c2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffefe; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffc2ba; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000027f000000fe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfe80000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000018000000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffff7a53; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff0000ff86; ++ *((unsigned long *)&__m128i_op11) = 0xffa6ff91fdd8ef77; ++ *((unsigned long *)&__m128i_op10) = 0x061202bffb141c38; ++ *((unsigned long *)&__m128i_result1) = 0x0000005a00000228; ++ *((unsigned long *)&__m128i_result0) = 0xfffff9ee000004ec; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op00) = 0x000000001fe02000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op10) = 0x000000001fe02000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb020302101b03; ++ *((unsigned long *)&__m128i_op00) = 0x020310d0c0030220; ++ *((unsigned long *)&__m128i_op11) = 0x0000000002345454; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c0dec4ca; ++ *((unsigned long *)&__m128i_result1) = 0x000030ebffffffdc; ++ *((unsigned long *)&__m128i_result0) = 0x00000203ffffff25; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x380fdfdfc0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffc7f100004000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00005dcbe7e830c0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000015d926c7; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000e41b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000005dcb; ++ __m128i_out = __lsx_vsubwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00f0008100800080; ++ *((unsigned long *)&__m128i_op00) = 0x00f000807000009e; ++ *((unsigned long *)&__m128i_op11) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op10) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000ec382e; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ec382d; ++ __m128i_out = __lsx_vsubwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128i_op00) = 0xfcfcfcfcfcfc0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffcfcfcfc; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffcfc6080; ++ __m128i_out = __lsx_vsubwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op00) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_op11) = 0xffaefffbffaefffb; ++ *((unsigned long *)&__m128i_op10) = 0xffaefffbffaefffb; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffc105d1aa; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffbc19ecca; ++ __m128i_out = __lsx_vsubwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000101fd01fe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffff0000000ad3d; ++ *((unsigned long *)&__m128i_op00) = 0xfffff000fffff000; ++ *((unsigned long *)&__m128i_op11) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xefffdffff0009d3d; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffff00ffffff01; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000100010001007c; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5f675e96e29a5a60; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op11) = 0x00fe000100cf005f; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x5e695e95e1cb5a01; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7efefefe82010201; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-2.c +new file mode 100644 +index 000000000..62837f1ac +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsubwod-2.c +@@ -0,0 +1,308 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfe07e5fefefdddfe; ++ *((unsigned long *)&__m128i_op10) = 0x00020100fedd0c00; ++ *((unsigned long *)&__m128i_result1) = 0xff02ff1bff02ff23; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffffff02fff4; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffefff6fff80002; ++ *((unsigned long *)&__m128i_op11) = 0x82c53a0000000000; ++ *((unsigned long *)&__m128i_op10) = 0xc72ef153fc02fdf7; ++ *((unsigned long *)&__m128i_result1) = 0x007d00c500ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x0038000e0003ff03; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007f000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007f000000000000; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000040000000400; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000000000010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff800000000000; ++ __m128i_out = __lsx_vsubwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfc01fd1300000001; ++ *((unsigned long *)&__m128i_op00) = 0xfe00fd1400010000; ++ *((unsigned long *)&__m128i_op11) = 0xfc01fd1300000001; ++ *((unsigned long *)&__m128i_op10) = 0xfe00fd1400010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffff800; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vsubwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op11) = 0xfe813f00fe813f00; ++ *((unsigned long *)&__m128i_op10) = 0xfe813f00fe813f00; ++ *((unsigned long *)&__m128i_result1) = 0xffff017fffff017f; ++ *((unsigned long *)&__m128i_result0) = 0xffff017fffff017f; ++ __m128i_out = __lsx_vsubwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x9c7c266e71768fa4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00009c7c00007176; ++ __m128i_out = __lsx_vsubwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vsubwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000009; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000897957687; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000408; ++ *((unsigned long *)&__m128i_op11) = 0x7fff0007e215b122; ++ *((unsigned long *)&__m128i_op10) = 0x7ffeffff7bfff828; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff80010001; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff80010001; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000af555555555; ++ *((unsigned long *)&__m128i_op00) = 0x00000af555555555; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000af5; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000af5; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x2e34594c3b000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000002e34594c; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsubwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000036280001; ++ *((unsigned long *)&__m128i_op00) = 0x42a0000042a02001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000036280001; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd0b1ffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x9d519ee8d2d84f1d; ++ *((unsigned long *)&__m128i_op11) = 0x8644ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4a6d0000ffff0000; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x82c539ffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xc72df14afbfafdf9; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7d3ac60000000000; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00fe00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010000; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000fffffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x0000102020204000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfefff00000001fff; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0003000300000000; ++ *((unsigned long *)&__m128i_op10) = 0x0003000300a10003; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffcfffd00000000; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x6363636163636363; ++ __m128i_out = __lsx_vsubwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vabsd-vmskgez-vmsk.patch
Added
@@ -0,0 +1,1710 @@ +From 7fc7953897e6ff488eebd5ea769447b7a1a7a0ed Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 18:48:08 +0800 +Subject: PATCH 087/124 LoongArch: Add tests for SX vector + vabsd/vmskgez/vmskltz/vmsknz/vsigncov instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vabsd-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vabsd-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmskgez.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmskltz.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmsknz.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsigncov.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vabsd-1.c | 272 +++++++++++ + .../loongarch/vector/lsx/lsx-vabsd-2.c | 398 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vmskgez.c | 119 +++++ + .../loongarch/vector/lsx/lsx-vmskltz.c | 321 +++++++++++++ + .../loongarch/vector/lsx/lsx-vmsknz.c | 104 +++++ + .../loongarch/vector/lsx/lsx-vsigncov.c | 425 ++++++++++++++++++ + 6 files changed, 1639 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskgez.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskltz.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsknz.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsigncov.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-1.c +new file mode 100644 +index 000000000..e336581f3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-1.c +@@ -0,0 +1,272 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfda9b23a624082fd; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001010000; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffd000700000000; ++ *((unsigned long *)&__m128i_op10) = 0x0014fff500000000; ++ *((unsigned long *)&__m128i_result1) = 0x7f03000780000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f15000a7f010101; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000060000000e; ++ *((unsigned long *)&__m128i_op10) = 0x000000127fffffea; ++ *((unsigned long *)&__m128i_result1) = 0x7f0101070101010f; ++ *((unsigned long *)&__m128i_result0) = 0x000000127f010116; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000b; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x67eb85af0000b000; ++ *((unsigned long *)&__m128i_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0x67157b5100005000; ++ *((unsigned long *)&__m128i_result0) = 0x387c7e0a133f2000; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff7fffefffa01ff; ++ *((unsigned long *)&__m128i_op00) = 0xfffbfffefffe01ff; ++ *((unsigned long *)&__m128i_op11) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128i_op10) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128i_result1) = 0x0305030203020502; ++ *((unsigned long *)&__m128i_result0) = 0x0301030203020502; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4ee376188658d85f; ++ *((unsigned long *)&__m128i_op00) = 0x5728dcc85ac760d2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4e1d76187a58285f; ++ *((unsigned long *)&__m128i_result0) = 0x572824385a39602e; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf654ad7447e59090; ++ *((unsigned long *)&__m128i_op10) = 0x27b1b106b8145f50; ++ *((unsigned long *)&__m128i_result1) = 0x0a545374471b7070; ++ *((unsigned long *)&__m128i_result0) = 0x274f4f0648145f50; ++ __m128i_out = __lsx_vabsd_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21f32eafa486fd38; ++ *((unsigned long *)&__m128i_op00) = 0x407c2ca3d3430357; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x21f32eaf5b7a02c8; ++ *((unsigned long *)&__m128i_result0) = 0x407c2ca32cbd0357; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003bfb4000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000003bfb4000; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100010001; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffdf; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000021; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x000700000004e000; ++ *((unsigned long *)&__m128i_op10) = 0x0003000000012020; ++ *((unsigned long *)&__m128i_result1) = 0x0038000000051fff; ++ *((unsigned long *)&__m128i_result0) = 0x003c000000022021; ++ __m128i_out = __lsx_vabsd_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9d9b9bbfaa20e9; ++ *((unsigned long *)&__m128i_op00) = 0xbe081c963e6fee68; ++ *((unsigned long *)&__m128i_op11) = 0x0000feff23560000; ++ *((unsigned long *)&__m128i_op10) = 0x0000fd1654860000; ++ *((unsigned long *)&__m128i_result1) = 0x6363636463abdf17; ++ *((unsigned long *)&__m128i_result0) = 0x41f8e08016161198; ++ __m128i_out = __lsx_vabsd_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vabsd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op00) = 0xff01fe0400000006; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000005fffa; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_result0) = 0x00fe01fc0005fff4; ++ __m128i_out = __lsx_vabsd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vabsd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x010003f00000ff00; ++ *((unsigned long *)&__m128i_op00) = 0x017f03000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x010003f00000ff00; ++ *((unsigned long *)&__m128i_op10) = 0x017f03000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x000000001fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000001ffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vabsd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffac0a000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffac0a000000; ++ __m128i_out = __lsx_vabsd_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-2.c +new file mode 100644 +index 000000000..c1af80e14 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vabsd-2.c +@@ -0,0 +1,398 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xa8beed87bc3f2be1; ++ *((unsigned long *)&__m128i_op00) = 0x0024d8f6a494006a; ++ *((unsigned long *)&__m128i_op11) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x5641127843c0d41e; ++ *((unsigned long *)&__m128i_result0) = 0xfedb27095b6bff95; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000383ffff1fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ca354688; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000038335ca2777; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fff80000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fff80000; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0002ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001fd0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001fd0; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ff08ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ff08ffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff0; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfefff00000001fff; ++ *((unsigned long *)&__m128i_op11) = 0xffe1ffc100000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000400000; ++ *((unsigned long *)&__m128i_result1) = 0xffe1ffc100000000; ++ *((unsigned long *)&__m128i_result0) = 0xfefff00000401fff; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff000000ff000000; ++ *((unsigned long *)&__m128i_op10) = 0xff000000ff000000; ++ *((unsigned long *)&__m128i_result1) = 0xff000000ff000000; ++ *((unsigned long *)&__m128i_result0) = 0xff000000ff000000; ++ __m128i_out = __lsx_vabsd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x13f9c5b60028a415; ++ *((unsigned long *)&__m128i_op00) = 0x545cab1d7e57c415; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x13f9c5b60028a415; ++ *((unsigned long *)&__m128i_result0) = 0x545cab1d81a83bea; ++ __m128i_out = __lsx_vabsd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_op11) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffcfb799f1; ++ *((unsigned long *)&__m128i_op00) = 0x0282800002828282; ++ *((unsigned long *)&__m128i_op11) = 0x5555001400005111; ++ *((unsigned long *)&__m128i_op10) = 0xffabbeab55110140; ++ *((unsigned long *)&__m128i_result1) = 0xaaaaffebcfb748e0; ++ *((unsigned long *)&__m128i_result0) = 0xfd293eab528e7ebe; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7505443065413aed; ++ *((unsigned long *)&__m128i_op00) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_op11) = 0x7505443065413aed; ++ *((unsigned long *)&__m128i_op10) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x56a09e662ab46b31; ++ *((unsigned long *)&__m128i_op00) = 0xb4b8122ef4054bb3; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x56a09e662ab46b31; ++ *((unsigned long *)&__m128i_result0) = 0xb4b8122ef4054bb3; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_op11) = 0x3c600000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xc39fffff007fffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000fe00fd; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8006000080020000; ++ *((unsigned long *)&__m128i_op10) = 0x8004000080020000; ++ *((unsigned long *)&__m128i_result1) = 0x8006000080020000; ++ *((unsigned long *)&__m128i_result0) = 0x8004000080020000; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100013fa0; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff0015172b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffb00151727; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffbfffffff8; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffbfffffff8; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffdc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffbffffffd8; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffbfffffff8; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000006; ++ *((unsigned long *)&__m128i_op11) = 0x000000490000004d; ++ *((unsigned long *)&__m128i_op10) = 0x00000001ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000490000004d; ++ *((unsigned long *)&__m128i_result0) = 0x00000001fffffff9; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4101010141010100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x64b680a2ae3af8c8; ++ *((unsigned long *)&__m128i_op10) = 0x161c0c363c200824; ++ *((unsigned long *)&__m128i_result1) = 0x23b57fa16d39f7c8; ++ *((unsigned long *)&__m128i_result0) = 0x161c0c363c200824; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0010000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3ff0010000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3fffff0000000000; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x1ffffffff8001000; ++ *((unsigned long *)&__m128i_op10) = 0xf0bd80bd80bd8000; ++ *((unsigned long *)&__m128i_result1) = 0x1ffffffff8001000; ++ *((unsigned long *)&__m128i_result0) = 0xf0bd80bd80bd8000; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffef8; ++ *((unsigned long *)&__m128i_result0) = 0xffdfffdfffdffee0; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vabsd_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskgez.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskgez.c +new file mode 100644 +index 000000000..64a950f81 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskgez.c +@@ -0,0 +1,119 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0403cfcf01c1595e; ++ *((unsigned long *)&__m128i_op00) = 0x837cd5db43fc55d4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000cb4a; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff7f01ff01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000d; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfe813f00fe813f00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000033; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fffe00006aea; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffce; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskgez_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskltz.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskltz.c +new file mode 100644 +index 000000000..8f743ec2e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmskltz.c +@@ -0,0 +1,321 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x85bd6b0e94d89998; ++ *((unsigned long *)&__m128i_op00) = 0xd83c8081ffff8080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000f; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7505443065413aed; ++ *((unsigned long *)&__m128i_op00) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000013d; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x00000000f0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000002; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000100010001fffd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000010001; ++ *((unsigned long *)&__m128i_op00) = 0x000000000001007c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111113111111141; ++ *((unsigned long *)&__m128i_op00) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9780697084f07dd7; ++ *((unsigned long *)&__m128i_op00) = 0x87e3285243051cf3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000cdc1; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x05d0ae6002e8748e; ++ *((unsigned long *)&__m128i_op00) = 0xcd1de80217374041; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000065a0; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000a0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000004b01; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_op00) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff00; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e1d1c1b1a; ++ *((unsigned long *)&__m128i_op00) = 0x1918171615141312; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000f; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ff08ffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000003f3f; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000022; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000008080600; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fff0018; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000035697d4e; ++ *((unsigned long *)&__m128i_op00) = 0x000000013ecaadf2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000006de1; ++ *((unsigned long *)&__m128i_op00) = 0x5f9ccf33cf600000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x003ffffe00800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000034; ++ __m128i_out = __lsx_vmskltz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128i_op00) = 0xc3818bffe7b7a7b8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x63636b6afe486741; ++ *((unsigned long *)&__m128i_op00) = 0x41f8e880ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000027; ++ __m128i_out = __lsx_vmskltz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmskltz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsknz.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsknz.c +new file mode 100644 +index 000000000..d547af0d3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmsknz.c +@@ -0,0 +1,104 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001e1f; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c63636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x009500b10113009c; ++ *((unsigned long *)&__m128i_op00) = 0x009500b10113009c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000005d5d; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffff000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000fe; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000fffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0010000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000007f41; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x0014001400140000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000554; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x202544f490f2de35; ++ *((unsigned long *)&__m128i_op00) = 0x202544f490f2de35; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000a74aa8a55ab; ++ *((unsigned long *)&__m128i_op00) = 0x6adeb5dfcb000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000003ff8; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x317fce80317fce80; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff00; ++ __m128i_out = __lsx_vmsknz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsigncov.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsigncov.c +new file mode 100644 +index 000000000..0fb1bc18f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsigncov.c +@@ -0,0 +1,425 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00003f803f800100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op10) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x870968c1f56bb3cd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf000e001bf84df83; ++ *((unsigned long *)&__m128i_op00) = 0xfff8e001ff84e703; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ca354688; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff35cab978; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x6a57a30ff0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe00fe00fe00fd01; ++ *((unsigned long *)&__m128i_op00) = 0xfe00fffefe0100f6; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op10) = 0xffffff0000010000; ++ *((unsigned long *)&__m128i_result1) = 0x0100010000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0100010000010000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000020000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000183fffffe5; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000400000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000400000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff3d06ffff4506; ++ *((unsigned long *)&__m128i_op10) = 0x7ffffffe7ffff800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result1) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_result0) = 0xfff6fff6fff6fff6; ++ __m128i_out = __lsx_vsigncov_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op10) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result1) = 0x3f80000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3f80000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m128i_op00) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x52525252525252cb; ++ *((unsigned long *)&__m128i_op10) = 0x52525252525252cb; ++ *((unsigned long *)&__m128i_result1) = 0xaeaeaeaeaeaeae35; ++ *((unsigned long *)&__m128i_result0) = 0xaeaeaeaeaeaeae35; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op11) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op10) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_result1) = 0x370bdfec00130014; ++ *((unsigned long *)&__m128i_result0) = 0x370bdfec00130014; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002020002020200; ++ *((unsigned long *)&__m128i_op00) = 0x021f3b0205150600; ++ *((unsigned long *)&__m128i_op11) = 0x0001000300400002; ++ *((unsigned long *)&__m128i_op10) = 0x000100010040fffb; ++ *((unsigned long *)&__m128i_result1) = 0x0001000300400002; ++ *((unsigned long *)&__m128i_result0) = 0x000100010040fffb; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ff801c9e; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000810000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_op10) = 0x008003496dea0c61; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0101030100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op00) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000400000004; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op11) = 0x1ab6021f72496458; ++ *((unsigned long *)&__m128i_op10) = 0x7750af4954c29940; ++ *((unsigned long *)&__m128i_result1) = 0xe64afee18eb79ca8; ++ *((unsigned long *)&__m128i_result0) = 0x89b051b7ac3e67c0; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x441ba9fcffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x181b2541ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff81010102; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000045340a6; ++ *((unsigned long *)&__m128i_op00) = 0x0000000028404044; ++ *((unsigned long *)&__m128i_op11) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0010001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op11) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0x67eb85af0000b000; ++ *((unsigned long *)&__m128i_result0) = 0xc8847ef6ed3f2000; ++ __m128i_out = __lsx_vsigncov_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000103; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffc; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000034; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x003ffffe00800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x004001be00dc008e; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ffff0100010001; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfff9fffefff9ffff; ++ *((unsigned long *)&__m128i_op11) = 0x04faf60009f5f092; ++ *((unsigned long *)&__m128i_op10) = 0x04fafa9200000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfc06066e00000000; ++ __m128i_out = __lsx_vsigncov_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffe0002; ++ *((unsigned long *)&__m128i_op11) = 0x000000000667ae56; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result1) = 0x000000000667ae56; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000020; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000100020002; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000100020002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000100020002; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010012; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffe1ffc0; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010012; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffe1ffc0; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010012; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffe1ffc0; ++ __m128i_out = __lsx_vsigncov_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vand-vandi-vandn-v.patch
Added
@@ -0,0 +1,1209 @@ +From ea0d56b6569735448905780fe8468c9b3c6aad14 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 18:58:17 +0800 +Subject: PATCH 097/124 LoongArch: Add tests for SX vector + vand/vandi/vandn/vor/vori/vnor/ vnori/vxor/vxori instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vand.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vandi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vandn.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vnor.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vnori.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vor.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vori.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vorn.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vxor.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vxori.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vand.c | 159 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vandi.c | 67 +++++++ + .../loongarch/vector/lsx/lsx-vandn.c | 129 +++++++++++++ + .../loongarch/vector/lsx/lsx-vnor.c | 109 +++++++++++ + .../loongarch/vector/lsx/lsx-vnori.c | 91 ++++++++++ + .../gcc.target/loongarch/vector/lsx/lsx-vor.c | 169 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vori.c | 123 +++++++++++++ + .../loongarch/vector/lsx/lsx-vorn.c | 109 +++++++++++ + .../loongarch/vector/lsx/lsx-vxor.c | 79 ++++++++ + .../loongarch/vector/lsx/lsx-vxori.c | 67 +++++++ + 10 files changed, 1102 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vand.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnori.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vori.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vorn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxori.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vand.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vand.c +new file mode 100644 +index 000000000..1597749b5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vand.c +@@ -0,0 +1,159 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x03574e3a62407e03; ++ *((unsigned long*)& __m128i_op10) = 0x0000000001010000; ++ *((unsigned long*)& __m128i_result1) = 0x03574e3a62407e03; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op11) = 0x001fffff001fffff; ++ *((unsigned long*)& __m128i_op10) = 0x001fffff001fffff; ++ *((unsigned long*)& __m128i_result1) = 0x001fffff001fffff; ++ *((unsigned long*)& __m128i_result0) = 0x001fffff001fffff; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000003dffc2; ++ *((unsigned long*)& __m128i_op00) = 0x00000000003dffc2; ++ *((unsigned long*)& __m128i_op11) = 0x0008000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000ffff53d9; ++ *((unsigned long*)& __m128i_op00) = 0xffff0001ffff9515; ++ *((unsigned long*)& __m128i_op11) = 0x00000000ffff53d9; ++ *((unsigned long*)& __m128i_op10) = 0xffff0001ffff9515; ++ *((unsigned long*)& __m128i_result1) = 0x00000000ffff53d9; ++ *((unsigned long*)& __m128i_result0) = 0xffff0001ffff9515; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x67eb85af0000b000; ++ *((unsigned long*)& __m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long*)& __m128i_op11) = 0x67eb85af0000b000; ++ *((unsigned long*)& __m128i_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long*)& __m128i_result1) = 0x67eb85af0000b000; ++ *((unsigned long*)& __m128i_result0) = 0xc8847ef6ed3f2000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0313100003131000; ++ *((unsigned long*)& __m128i_op10) = 0x0313100003131000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000200000002; ++ *((unsigned long*)& __m128i_op11) = 0x0007000000050000; ++ *((unsigned long*)& __m128i_op10) = 0x0003000100010001; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00007a8000000480; ++ *((unsigned long*)& __m128i_op00) = 0x00000485000004cc; ++ *((unsigned long*)& __m128i_op11) = 0x0a0000000a000000; ++ *((unsigned long*)& __m128i_op10) = 0x0a0000000a000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vand_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandi.c +new file mode 100644 +index 000000000..906da69ca +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandi.c +@@ -0,0 +1,67 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandi_b(__m128i_op0,0x36); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000800; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000800; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandi_b(__m128i_op0,0x39); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandi_b(__m128i_op0,0x27); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandi_b(__m128i_op0,0x25); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandi_b(__m128i_op0,0xbd); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000a95afc60a5c5; ++ *((unsigned long*)& __m128i_op00) = 0x0000b6e414157f84; ++ *((unsigned long*)& __m128i_result1) = 0x0000204264602444; ++ *((unsigned long*)& __m128i_result0) = 0x0000266404046604; ++ __m128i_out = __lsx_vandi_b(__m128i_op0,0x66); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandn.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandn.c +new file mode 100644 +index 000000000..3ae2d7694 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vandn.c +@@ -0,0 +1,129 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x000000017fff9000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000210011084; ++ *((unsigned long*)& __m128i_result1) = 0x000000017fff9000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000210011084; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000100000000; ++ *((unsigned long*)& __m128i_op11) = 0x00000049000000c0; ++ *((unsigned long*)& __m128i_op10) = 0x00000001ffffff29; ++ *((unsigned long*)& __m128i_result1) = 0x00000049000000c0; ++ *((unsigned long*)& __m128i_result0) = 0x00000000ffffff29; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x010f00000111fffc; ++ *((unsigned long*)& __m128i_op00) = 0x016700dc0176003a; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0003000000010000; ++ *((unsigned long*)& __m128i_op00) = 0x0002000000010000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x8000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0xfffffffffffff000; ++ *((unsigned long*)& __m128i_op11) = 0x8000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0xfffffffffffff000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x62cbf96e4acfaf40; ++ *((unsigned long*)& __m128i_op10) = 0xf0bc9a5278285a4a; ++ *((unsigned long*)& __m128i_result1) = 0x62cbf96e4acfaf40; ++ *((unsigned long*)& __m128i_result0) = 0xf0bc9a5278285a4a; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0xfffe0004fffe0004; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x9c7c266e71768fa4; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x9c7c266e71768fa4; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vandn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnor.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnor.c +new file mode 100644 +index 000000000..a7a3acce9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnor.c +@@ -0,0 +1,109 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000fff8fff8; ++ *((unsigned long*)& __m128i_op00) = 0x00000000fff80000; ++ *((unsigned long*)& __m128i_op11) = 0x00000000fff8fff8; ++ *((unsigned long*)& __m128i_op10) = 0x00000000fff80000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffff00070007; ++ *((unsigned long*)& __m128i_result0) = 0xffffffff0007ffff; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xce23d33e43d9736c; ++ *((unsigned long*)& __m128i_op00) = 0x63b2ac27aa076aeb; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x31dc2cc1bc268c93; ++ *((unsigned long*)& __m128i_result0) = 0x9c4d53d855f89514; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x000000000000000c; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xfffffffffffffff3; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000400080003fff; ++ *((unsigned long*)& __m128i_op00) = 0x0000bc2000007e04; ++ *((unsigned long*)& __m128i_op11) = 0x0000400080003fff; ++ *((unsigned long*)& __m128i_op10) = 0x0000bc2000007e04; ++ *((unsigned long*)& __m128i_result1) = 0xffffbfff7fffc000; ++ *((unsigned long*)& __m128i_result0) = 0xffff43dfffff81fb; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x021b7d24c9678a35; ++ *((unsigned long*)& __m128i_op00) = 0x030298a6a1030a49; ++ *((unsigned long*)& __m128i_op11) = 0x5252525252525252; ++ *((unsigned long*)& __m128i_op10) = 0x5252525252525252; ++ *((unsigned long*)& __m128i_result1) = 0xada4808924882588; ++ *((unsigned long*)& __m128i_result0) = 0xacad25090caca5a4; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0xfffefffe0000ff18; ++ *((unsigned long*)& __m128i_op11) = 0xffff000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long*)& __m128i_result1) = 0x0000ffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0x0001000100000000; ++ __m128i_out = __lsx_vnor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnori.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnori.c +new file mode 100644 +index 000000000..a07a02ab2 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vnori.c +@@ -0,0 +1,91 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000ffff0000; ++ *((unsigned long*)& __m128i_op00) = 0x00000000ffff0000; ++ *((unsigned long*)& __m128i_result1) = 0xcccccccc0000cccc; ++ *((unsigned long*)& __m128i_result0) = 0xcccccccc0000cccc; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0x33); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0xa6); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x3e035e51522f0799; ++ *((unsigned long*)& __m128i_result1) = 0x9292929292929292; ++ *((unsigned long*)& __m128i_result0) = 0x8090808280909002; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0x6d); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000000ffc2f; ++ *((unsigned long*)& __m128i_op00) = 0x00201df000000000; ++ *((unsigned long*)& __m128i_result1) = 0x3838383838300010; ++ *((unsigned long*)& __m128i_result0) = 0x3818200838383838; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0xc7); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x2020202020202020; ++ *((unsigned long*)& __m128i_op00) = 0x2020202020207f7f; ++ *((unsigned long*)& __m128i_result1) = 0x5d5d5d5d5d5d5d5d; ++ *((unsigned long*)& __m128i_result0) = 0x5d5d5d5d5d5d0000; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0xa2); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x8080808080808080; ++ *((unsigned long*)& __m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0x7f); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x8080808080808080; ++ *((unsigned long*)& __m128i_op00) = 0x8080808080808080; ++ *((unsigned long*)& __m128i_result1) = 0x1313131313131313; ++ *((unsigned long*)& __m128i_result0) = 0x1313131313131313; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0xec); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x9d9d9d9d9d9d9d9d; ++ *((unsigned long*)& __m128i_result0) = 0x9d9d9d9d9d9d9d9d; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0x62); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00f525682ffd27f2; ++ *((unsigned long*)& __m128i_op00) = 0x00365c60317ff930; ++ *((unsigned long*)& __m128i_result1) = 0xe500c085c000c005; ++ *((unsigned long*)& __m128i_result0) = 0xe5c1a185c48004c5; ++ __m128i_out = __lsx_vnori_b(__m128i_op0,0x1a); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vor.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vor.c +new file mode 100644 +index 000000000..537a1bb3b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vor.c +@@ -0,0 +1,169 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op11) = 0x7e44bde9b842ff23; ++ *((unsigned long*)& __m128i_op10) = 0x00011e80007edff8; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long*)& __m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000001; ++ *((unsigned long*)& __m128i_op10) = 0xfffc001fffffffff; ++ *((unsigned long*)& __m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xfffc001fffffffff; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000200010; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000200010; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000200010; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x4f804f804f804f80; ++ *((unsigned long*)& __m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long*)& __m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long*)& __m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long*)& __m128i_result1) = 0x4f804f804f804f80; ++ *((unsigned long*)& __m128i_result0) = 0x4f804f804f804f80; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x3e035e51522f0799; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x3e035e51522f0799; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x3e035e51522f0799; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long*)& __m128i_op00) = 0xffff000000000000; ++ *((unsigned long*)& __m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long*)& __m128i_op10) = 0xffff000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long*)& __m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0xffffffff00000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffff00000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xfffb00fdfdf7ffff; ++ *((unsigned long*)& __m128i_op00) = 0xfff8000000000000; ++ *((unsigned long*)& __m128i_op11) = 0xfffb00fdfdf7ffff; ++ *((unsigned long*)& __m128i_op10) = 0xfff8000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xfffb00fdfdf7ffff; ++ *((unsigned long*)& __m128i_result0) = 0xfff8000000000000; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffff80005613; ++ *((unsigned long*)& __m128i_op00) = 0x81000080806b000b; ++ *((unsigned long*)& __m128i_op11) = 0xffff00011cf0c569; ++ *((unsigned long*)& __m128i_op10) = 0xc0000002b0995850; ++ *((unsigned long*)& __m128i_result1) = 0xffffffff9cf0d77b; ++ *((unsigned long*)& __m128i_result0) = 0xc1000082b0fb585b; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0xfffffffffffbfff8; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x80808080806b000b; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0xfffffffffffbfffb; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0001000101010001; ++ *((unsigned long*)& __m128i_op00) = 0x0001000100010001; ++ *((unsigned long*)& __m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long*)& __m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long*)& __m128i_result1) = 0x0001ffff0101ffff; ++ *((unsigned long*)& __m128i_result0) = 0x0001ffff0001ffff; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffc105d1aa; ++ *((unsigned long*)& __m128i_op00) = 0xffffffffbc19ecca; ++ *((unsigned long*)& __m128i_op11) = 0xc0b4d1a5f8babad3; ++ *((unsigned long*)& __m128i_op10) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long*)& __m128i_result1) = 0xfffffffff9bffbfb; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffdffdfb; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vori.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vori.c +new file mode 100644 +index 000000000..8a6e035c9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vori.c +@@ -0,0 +1,123 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x8282828282828282; ++ *((unsigned long*)& __m128i_result0) = 0x8282828282828282; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x82); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x7505853d654185f5; ++ *((unsigned long*)& __m128i_op00) = 0x01010000fefe0101; ++ *((unsigned long*)& __m128i_result1) = 0x7545c57d6541c5f5; ++ *((unsigned long*)& __m128i_result0) = 0x41414040fefe4141; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x40); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000c2f90000bafa; ++ *((unsigned long*)& __m128i_op00) = 0x8000c2fa8000c2fa; ++ *((unsigned long*)& __m128i_result1) = 0x7474f6fd7474fefe; ++ *((unsigned long*)& __m128i_result0) = 0xf474f6fef474f6fe; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x74); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long*)& __m128i_result0) = 0x3d3d3d3d3d3d3d3d; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x3d); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xfffffacdb6dbecac; ++ *((unsigned long*)& __m128i_op00) = 0x1f5533a694f902c0; ++ *((unsigned long*)& __m128i_result1) = 0xfffffadffedbfefe; ++ *((unsigned long*)& __m128i_result0) = 0x5f5f7bfedefb5ada; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x5a); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x38); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0d1202e19235e2bc; ++ *((unsigned long*)& __m128i_op00) = 0xea38e0f75f6e56d1; ++ *((unsigned long*)& __m128i_result1) = 0x2f3626e7b637e6be; ++ *((unsigned long*)& __m128i_result0) = 0xee3ee6f77f6e76f7; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x26); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0003c853c843c87e; ++ *((unsigned long*)& __m128i_op00) = 0x0003c853c843c87e; ++ *((unsigned long*)& __m128i_result1) = 0xd6d7ded7ded7defe; ++ *((unsigned long*)& __m128i_result0) = 0xd6d7ded7ded7defe; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0xd6); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0xfffe0000fffe0000; ++ *((unsigned long*)& __m128i_result1) = 0x7777777777777777; ++ *((unsigned long*)& __m128i_result0) = 0xffff7777ffff7777; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x77); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x55); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x8000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x8000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xd454545454545454; ++ *((unsigned long*)& __m128i_result0) = 0xd454545454545454; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x54); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long*)& __m128i_result0) = 0x4f4f4f4f4f4f4f4f; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x4f); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x8a8a8a8a8a8a8a8a; ++ *((unsigned long*)& __m128i_result0) = 0x8a8a8a8a8a8a8a8a; ++ __m128i_out = __lsx_vori_b(__m128i_op0,0x8a); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vorn.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vorn.c +new file mode 100644 +index 000000000..bb59bc312 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vorn.c +@@ -0,0 +1,109 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x0001000100010001; ++ *((unsigned long*)& __m128i_op00) = 0x000100010001fffe; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x00d3012b015700bb; ++ *((unsigned long*)& __m128i_op10) = 0x00010000ffca0070; ++ *((unsigned long*)& __m128i_result1) = 0xff2cfed4fea8ff44; ++ *((unsigned long*)& __m128i_result0) = 0xfffeffff0035ff8f; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00fe00fe00fe00fe; ++ *((unsigned long*)& __m128i_op00) = 0x00fe00fe00fe0045; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0x00fe00fe00fe00fe; ++ *((unsigned long*)& __m128i_result0) = 0x00fe00fe00fe0045; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000010000010101; ++ *((unsigned long*)& __m128i_op00) = 0x0101000001000100; ++ *((unsigned long*)& __m128i_op11) = 0x0000010000010101; ++ *((unsigned long*)& __m128i_op10) = 0x0101000001000100; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000002; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000002; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x33f5c2d7d975d7fe; ++ *((unsigned long*)& __m128i_op00) = 0xe4423f7b769f8ffe; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x33f5c2d7d975d7fe; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00050eb00000fffa; ++ *((unsigned long*)& __m128i_op00) = 0x0000f8a50000f310; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00bbfff7fffffff7; ++ *((unsigned long*)& __m128i_op00) = 0xffffffff008ff820; ++ *((unsigned long*)& __m128i_op11) = 0x0001000100010012; ++ *((unsigned long*)& __m128i_op10) = 0x00000000ffe1ffc0; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffff009ff83f; ++ __m128i_out = __lsx_vorn_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxor.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxor.c +new file mode 100644 +index 000000000..72fa97174 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxor.c +@@ -0,0 +1,79 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x00000000f4012ceb; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x00000000f4012ceb; ++ __m128i_out = __lsx_vxor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vxor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vxor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x40f3fa0000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000001; ++ *((unsigned long*)& __m128i_op10) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x3ff0000000000001; ++ *((unsigned long*)& __m128i_result0) = 0x40f3fa0000000000; ++ __m128i_out = __lsx_vxor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op11) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op10) = 0x0000000080000068; ++ *((unsigned long*)& __m128i_result1) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result0) = 0x0000000080000068; ++ __m128i_out = __lsx_vxor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000ffff53d9; ++ *((unsigned long*)& __m128i_op00) = 0xff000001ffff9515; ++ *((unsigned long*)& __m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long*)& __m128i_op10) = 0xffff0001ffff9514; ++ *((unsigned long*)& __m128i_result1) = 0xffffffff0000ac26; ++ *((unsigned long*)& __m128i_result0) = 0x00ff000000000001; ++ __m128i_out = __lsx_vxor_v(__m128i_op0,__m128i_op1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxori.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxori.c +new file mode 100644 +index 000000000..cc823d4ba +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vxori.c +@@ -0,0 +1,67 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i=1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x0404040404040404; ++ *((unsigned long*)& __m128i_result0) = 0x0404040404040404; ++ __m128i_out = __lsx_vxori_b(__m128i_op0,0x4); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000001000100; ++ *((unsigned long*)& __m128i_op00) = 0x0000000001000100; ++ *((unsigned long*)& __m128i_result1) = 0x5a5a5a5a5b5a5b5a; ++ *((unsigned long*)& __m128i_result0) = 0x5a5a5a5a5b5a5b5a; ++ __m128i_out = __lsx_vxori_b(__m128i_op0,0x5a); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0xe3e3e3e3e3e3e3e3; ++ *((unsigned long*)& __m128i_result0) = 0xe3e3e3e3e3e3e3e3; ++ __m128i_out = __lsx_vxori_b(__m128i_op0,0xe3); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0020002000200020; ++ *((unsigned long*)& __m128i_result1) = 0x9a9a9a9a9a9a9a9a; ++ *((unsigned long*)& __m128i_result0) = 0x9aba9aba9aba9aba; ++ __m128i_out = __lsx_vxori_b(__m128i_op0,0x9a); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_op00) = 0x0000000000000000; ++ *((unsigned long*)& __m128i_result1) = 0x9090909090909090; ++ *((unsigned long*)& __m128i_result0) = 0x9090909090909090; ++ __m128i_out = __lsx_vxori_b(__m128i_op0,0x90); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ *((unsigned long*)& __m128i_op01) = 0x00000000b81c8382; ++ *((unsigned long*)& __m128i_op00) = 0x0000000077af9450; ++ *((unsigned long*)& __m128i_result1) = 0xf1f1f1f149ed7273; ++ *((unsigned long*)& __m128i_result0) = 0xf1f1f1f1865e65a1; ++ __m128i_out = __lsx_vxori_b(__m128i_op0,0xf1); ++ ASSERTEQ_64(__LINE__, __m128i_result, __m128i_out); ++ ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vavg-vavgr-instruc.patch
Added
@@ -0,0 +1,1375 @@ +From 4fba531ee417a29234e8be84e17cddc7dd9ec343 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 18:35:55 +0800 +Subject: PATCH 084/124 LoongArch: Add tests for SX vector vavg/vavgr + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vavg-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vavg-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vavgr-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vavgr-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vavg-1.c | 398 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vavg-2.c | 308 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vavgr-1.c | 299 +++++++++++++ + .../loongarch/vector/lsx/lsx-vavgr-2.c | 317 ++++++++++++++ + 4 files changed, 1322 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-1.c +new file mode 100644 +index 000000000..2177ca3f6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-1.c +@@ -0,0 +1,398 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m128i_op00) = 0xfff8fff8fff8fff8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_result0) = 0xfffcfffcfffcfffc; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x4050000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x2028000000000000; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000014155445; ++ *((unsigned long *)&__m128i_result1) = 0x33f5c2d7d9f5d800; ++ *((unsigned long *)&__m128i_result0) = 0xe4c23ffb002a3a22; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000f000e; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000ffffe; ++ *((unsigned long *)&__m128i_result1) = 0x003fffff00070007; ++ *((unsigned long *)&__m128i_result0) = 0x000000000007ffff; ++ __m128i_out = __lsx_vavg_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400028000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0x000000020001c020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000022; ++ __m128i_out = __lsx_vavg_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x08080807f5f5f5f8; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x04040403fafafafc; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff80; ++ __m128i_out = __lsx_vavg_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x10f8000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x00000001000010f8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x087c000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000087c; ++ __m128i_out = __lsx_vavg_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5641127843c0d41e; ++ *((unsigned long *)&__m128i_op00) = 0xfedb27095b6bff95; ++ *((unsigned long *)&__m128i_op11) = 0xa8beed87bc3f2be1; ++ *((unsigned long *)&__m128i_op10) = 0x0024d8f6a494006a; ++ *((unsigned long *)&__m128i_result1) = 0xff7fffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xff7fffffffffffff; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00007fff; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff80ff0010ff06; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0xedfaedfaedfaedfa; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0xf6fd377cf705f680; ++ *((unsigned long *)&__m128i_result0) = 0xc0000000bfff8000; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000007fff; ++ *((unsigned long *)&__m128i_op00) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000f00; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x1ff800000000477f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000015fec9b0; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000037; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x003fffff00000000; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000800000008000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000008000; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd6a09e662ab46b31; ++ *((unsigned long *)&__m128i_op00) = 0x34b8122ef4054bb3; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xeb504f33155a3598; ++ *((unsigned long *)&__m128i_result0) = 0x1a5c0917fa02a5d9; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0177fff0fffffff0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000011ff8bc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffefffff784; ++ *((unsigned long *)&__m128i_result1) = 0x00bbfff7fffffff7; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff008ff820; ++ __m128i_out = __lsx_vavg_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x00001802041b0014; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000c01020d8009; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000201000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000007fff8000; ++ *((unsigned long *)&__m128i_result0) = 0x0001008100000005; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfc01fd1300000001; ++ *((unsigned long *)&__m128i_op00) = 0xfe00fd1400010000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fff7fc01; ++ *((unsigned long *)&__m128i_result1) = 0xfe00fe8980000000; ++ *((unsigned long *)&__m128i_result0) = 0xff007e8a7ffc7e00; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffe00000002; ++ *((unsigned long *)&__m128i_op10) = 0xffffff46000000ba; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffa30000005c; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000070007; ++ *((unsigned long *)&__m128i_op00) = 0x000000000007ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000068; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000038003; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000040033; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff0000ac26; ++ *((unsigned long *)&__m128i_op10) = 0x00ff000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff80005613; ++ *((unsigned long *)&__m128i_result0) = 0x007f800000000000; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000040000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000040000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result1) = 0x3fc000005fc00000; ++ *((unsigned long *)&__m128i_result0) = 0x3fc000005fc00000; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100000000; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000fffe0001; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff0001fffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff0000ffff; ++ __m128i_out = __lsx_vavg_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-2.c +new file mode 100644 +index 000000000..1b0d879e4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavg-2.c +@@ -0,0 +1,308 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m128i_out = __lsx_vavg_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m128i_out = __lsx_vavg_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m128i_out = __lsx_vavg_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000100000001000; ++ *((unsigned long *)&__m128i_op00) = 0x37b951002d81a921; ++ *((unsigned long *)&__m128i_op11) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_op10) = 0x000047404f4f040d; ++ *((unsigned long *)&__m128i_result1) = 0x0000082000000826; ++ *((unsigned long *)&__m128i_result0) = 0x1b5c4c203e685617; ++ __m128i_out = __lsx_vavg_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128i_op00) = 0x00a975be00accf03; ++ *((unsigned long *)&__m128i_op11) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128i_op10) = 0x00a975be00accf03; ++ *((unsigned long *)&__m128i_result1) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128i_result0) = 0x00a975be00accf03; ++ __m128i_out = __lsx_vavg_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0100000001000100; ++ *((unsigned long *)&__m128i_op00) = 0x0100010000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff732a; ++ *((unsigned long *)&__m128i_result1) = 0x807f7fff807f807f; ++ *((unsigned long *)&__m128i_result0) = 0x807f807f7fff3995; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000007f7f7f7f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x000000003fbf3fbf; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff7ff8; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op00) = 0x353c8cc4b1ec5b09; ++ *((unsigned long *)&__m128i_op11) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8080008000808080; ++ *((unsigned long *)&__m128i_result0) = 0x1a9e466258f62d84; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ac; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x9c9c9c9c00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result1) = 0x4e4e4e4e00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000868686868686; ++ *((unsigned long *)&__m128i_op11) = 0x1e1e1e1e1e1e1e1e; ++ *((unsigned long *)&__m128i_op10) = 0x1e1e1e1e1e1e1e1e; ++ *((unsigned long *)&__m128i_result1) = 0x0f0f0f0f0f0f0f0f; ++ *((unsigned long *)&__m128i_result0) = 0x0f0f525252525252; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128i_op00) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffdfdc0d; ++ *((unsigned long *)&__m128i_result1) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_result0) = 0x0a753500950fa306; ++ __m128i_out = __lsx_vavg_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_op00) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_op11) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_op10) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result1) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result0) = 0xfffff00010000fff; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000002ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000017fffffff; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0101000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0101030100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0080800000008000; ++ *((unsigned long *)&__m128i_result0) = 0x0080818000008000; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000002; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0017004800c400f9; ++ *((unsigned long *)&__m128i_op00) = 0x00ed001a00580070; ++ *((unsigned long *)&__m128i_op11) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x800b7fe38062007b; ++ *((unsigned long *)&__m128i_result0) = 0x0076800d802c0037; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80ffa2fff0ff74; ++ *((unsigned long *)&__m128i_op00) = 0xff76ffd8ffe6ffaa; ++ *((unsigned long *)&__m128i_op11) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op10) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_result1) = 0xe01ae8a3fc55dd23; ++ *((unsigned long *)&__m128i_result0) = 0xdd9ff64ef9daeace; ++ __m128i_out = __lsx_vavg_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fffffff; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f80000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3f80000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x1fc0000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1fc07f8000007f80; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000043cf26c7; ++ *((unsigned long *)&__m128i_op10) = 0x0000e31d4cae8636; ++ *((unsigned long *)&__m128i_result1) = 0x0000000021e79364; ++ *((unsigned long *)&__m128i_result0) = 0x0000718ea657431b; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7ff8000000000000; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff80ffff7e02; ++ *((unsigned long *)&__m128i_op00) = 0x00feff8000ff80ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0xf931fd04f832fe02; ++ *((unsigned long *)&__m128i_result1) = 0x80007fc000003f00; ++ *((unsigned long *)&__m128i_result0) = 0x7d187e427c993f80; ++ __m128i_out = __lsx_vavg_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-1.c +new file mode 100644 +index 000000000..4b7262537 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-1.c +@@ -0,0 +1,299 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0040000000ff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x0040000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0020000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0020c00000000000; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xb9fe3640e4eb1b18; ++ *((unsigned long *)&__m128i_op00) = 0x800000005b4b1b18; ++ *((unsigned long *)&__m128i_op11) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xdcfe1b20f2f60e0c; ++ *((unsigned long *)&__m128i_result0) = 0xc00000002e260e0c; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x111110ff11111141; ++ *((unsigned long *)&__m128i_op00) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_op11) = 0xfbffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x7bffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x060808ff08080820; ++ *((unsigned long *)&__m128i_result0) = 0x4608081808080810; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000fff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000ac26; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000060000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000003000000d613; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c0000000; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff2; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff2; ++ __m128i_out = __lsx_vavgr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000073; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000002a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000003a; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000015; ++ __m128i_out = __lsx_vavgr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000004000; ++ *((unsigned long *)&__m128i_op10) = 0xfff8004000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_result0) = 0xfffc002000000000; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op00) = 0xfffc002000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op10) = 0xfffc002000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_result0) = 0xfffc002000000000; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff00000000; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000007fff0018; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000003fff800c; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0280000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7500000075000000; ++ *((unsigned long *)&__m128i_op10) = 0x7500000075000000; ++ *((unsigned long *)&__m128i_result1) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_result0) = 0x3bc000003a800000; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00007d1800007c99; ++ *((unsigned long *)&__m128i_op11) = 0x0a0000001e000000; ++ *((unsigned long *)&__m128i_op10) = 0x0a621b3ebe5e1c02; ++ *((unsigned long *)&__m128i_result1) = 0x04ffc0000f000000; ++ *((unsigned long *)&__m128i_result0) = 0x05314c2bdf2f4c4e; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000001000000000; ++ __m128i_out = __lsx_vavgr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result1) = 0x3fc000003fc00000; ++ *((unsigned long *)&__m128i_result0) = 0x3fc000003fc00000; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3fffffffc0000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op10) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result1) = 0xff807f807f807f80; ++ *((unsigned long *)&__m128i_result0) = 0xff807f807f807f80; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000280000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000140001; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff46; ++ *((unsigned long *)&__m128i_op11) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m128i_op10) = 0x00fe00fe00fe0045; ++ *((unsigned long *)&__m128i_result1) = 0x007f007f007f007e; ++ *((unsigned long *)&__m128i_result0) = 0x007f007f007effc6; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x33f5c2d7d975d7fe; ++ *((unsigned long *)&__m128i_result0) = 0xe4423f7b769f8ffe; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000003ff8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff9dff9dff9dff9d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffceffceffcf1fcb; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x3bc000003a800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00fe00fe7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x1d4000001d400000; ++ *((unsigned long *)&__m128i_result0) = 0x1e5f007f5d400000; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000400000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000007f80; ++ __m128i_out = __lsx_vavgr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-2.c +new file mode 100644 +index 000000000..22908b1ea +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vavgr-2.c +@@ -0,0 +1,317 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff01018888; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff01018888; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff01018888; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4080808080808080; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x000000010000003f; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x000000010000003f; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x000000010000003f; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffffffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op11) = 0x1817161517161514; ++ *((unsigned long *)&__m128i_op10) = 0x1615141315141312; ++ *((unsigned long *)&__m128i_result1) = 0x0c0c8b8a8b8b0b0a; ++ *((unsigned long *)&__m128i_result0) = 0x8b8a8a898a8a8909; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00003fff00003fff; ++ *((unsigned long *)&__m128i_op00) = 0x00003fff00003fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_result0) = 0x0000208000002080; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffd60015; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x80808080806b000b; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_op11) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_result1) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff81010102; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xc1bdceee242071db; ++ *((unsigned long *)&__m128i_op10) = 0xe8c7b756d76aa578; ++ *((unsigned long *)&__m128i_result1) = 0xe0dee7779210b8ed; ++ *((unsigned long *)&__m128i_result0) = 0xf463dbabebb5d2bc; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff80000000000000; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op10) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128i_result1) = 0x0000400400004004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000015ff4a31; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x2a7b7c9260f90ee2; ++ *((unsigned long *)&__m128i_op10) = 0x1b1c6cdfd57f5736; ++ *((unsigned long *)&__m128i_result1) = 0x153e3e49307d0771; ++ *((unsigned long *)&__m128i_result0) = 0x0d8e36706ac02b9b; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xdd6156076967d8c9; ++ *((unsigned long *)&__m128i_op00) = 0x2e3ab5266375e71b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result1) = 0x6eb12b0634b46c67; ++ *((unsigned long *)&__m128i_result0) = 0x171d5a9531bb7390; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000f50000000900; ++ *((unsigned long *)&__m128i_op00) = 0x0000090900000998; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00007a8000000480; ++ *((unsigned long *)&__m128i_result0) = 0x00000485000004cc; ++ __m128i_out = __lsx_vavgr_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00003ff000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fffc00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0xfffc001fffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00001ff800000001; ++ *((unsigned long *)&__m128i_result0) = 0x7ffe800e80000000; ++ __m128i_out = __lsx_vavgr_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op00) = 0xff000001ffff9515; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x000000007fffa9ed; ++ *((unsigned long *)&__m128i_result0) = 0x7f8000017fffca8b; ++ __m128i_out = __lsx_vavgr_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffdfffffff8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7ffffffc; ++ __m128i_out = __lsx_vavgr_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffeff98; ++ *((unsigned long *)&__m128i_op00) = 0x0014ffe4ff76ffc4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3131313131313131; ++ *((unsigned long *)&__m128i_result1) = 0x000000017fff7fcc; ++ *((unsigned long *)&__m128i_result0) = 0x18a3188b9854187b; ++ __m128i_out = __lsx_vavgr_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vavgr_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001c88bf0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001c88bf0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001c88bf0; ++ __m128i_out = __lsx_vavgr_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x807fffff80800000; ++ *((unsigned long *)&__m128i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_result1) = 0x8003000000020000; ++ *((unsigned long *)&__m128i_result0) = 0x4040ffffc0400004; ++ __m128i_out = __lsx_vavgr_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000010000010101; ++ *((unsigned long *)&__m128i_op00) = 0x0101000001000100; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x8000008000008080; ++ *((unsigned long *)&__m128i_result0) = 0x8080800000800080; ++ __m128i_out = __lsx_vavgr_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vavgr_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vbitclr-vbitclri-v.patch
Added
@@ -0,0 +1,3324 @@ +From 0b75b581703b0eb1eb9ca9e898255de7f4cb51ad Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 11:20:44 +0800 +Subject: PATCH 092/124 LoongArch: Add tests for SX vector + vbitclr/vbitclri/vbitrev/vbitrevi/ + vbitsel/vbitseli/vbitset/vbitseti/vclo/vclz/vpcnt instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vbitclr.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbitclri.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbitrev.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbitrevi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbitsel.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbitseli.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbitset.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vbitseti.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vclo.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vclz.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vpcnt.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vbitclr.c | 461 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vbitclri.c | 279 +++++++++++ + .../loongarch/vector/lsx/lsx-vbitrev.c | 407 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vbitrevi.c | 336 +++++++++++++ + .../loongarch/vector/lsx/lsx-vbitsel.c | 109 +++++ + .../loongarch/vector/lsx/lsx-vbitseli.c | 84 ++++ + .../loongarch/vector/lsx/lsx-vbitset.c | 371 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vbitseti.c | 279 +++++++++++ + .../loongarch/vector/lsx/lsx-vclo.c | 266 ++++++++++ + .../loongarch/vector/lsx/lsx-vclz.c | 265 ++++++++++ + .../loongarch/vector/lsx/lsx-vpcnt.c | 350 +++++++++++++ + 11 files changed, 3207 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclri.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrev.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrevi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitsel.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseli.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitset.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseti.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclo.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclz.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpcnt.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclr.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclr.c +new file mode 100644 +index 000000000..411dcaa40 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclr.c +@@ -0,0 +1,461 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000e0000000e0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00e0000000e00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000e0000000e0; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000004000; ++ *((unsigned long *)&__m128i_op10) = 0xfff8004000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x19df307a5d04acbb; ++ *((unsigned long *)&__m128i_op00) = 0x5ed032b06bde1ab6; ++ *((unsigned long *)&__m128i_op11) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x19de307a5d04acba; ++ *((unsigned long *)&__m128i_result0) = 0x5ed032b06bde1ab6; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0018001800180018; ++ *((unsigned long *)&__m128i_op10) = 0x0018001800180018; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xd8248069ffe78077; ++ *((unsigned long *)&__m128i_op11) = 0x85bd6b0e94d89998; ++ *((unsigned long *)&__m128i_op10) = 0xd83c8081ffff808f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xd82480697f678077; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000006597cc3d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x7505853d654185f5; ++ *((unsigned long *)&__m128i_op10) = 0x01010000fefe0101; ++ *((unsigned long *)&__m128i_result1) = 0x000000006595cc1d; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffe0000fffe0000; ++ *((unsigned long *)&__m128i_result0) = 0xfffe0000fffe0000; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x80000000fff7fc01; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x80000000fff6fc00; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffff800; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fffefffe; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fffef800; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffefffffffe; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4101010141010100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x4101010141010100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x23b57fa16d39f7c8; ++ *((unsigned long *)&__m128i_op10) = 0x161c0c363c200824; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000ffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000ffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op10) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000fefe00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fefe00000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x1ffffffff8001000; ++ *((unsigned long *)&__m128i_op10) = 0xf0bd80bd80bd8000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7ffffffefffe; ++ *((unsigned long *)&__m128i_result0) = 0xdfffdfffdffffffe; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000037; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000036; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000100000001007c; ++ *((unsigned long *)&__m128i_result0) = 0x0001000000010000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefa000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfefa000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67b7cf643c9d636a; ++ *((unsigned long *)&__m128i_op00) = 0x39d70e366f547977; ++ *((unsigned long *)&__m128i_op11) = 0x0002ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x66b34f643c9c626a; ++ *((unsigned long *)&__m128i_result0) = 0x38d60e366e547876; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x2020202020207fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_result0) = 0x2020202020207f7f; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x7ef8000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7ef8000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000077f97; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffeff7f0000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x14ccc6320176a4d2; ++ *((unsigned long *)&__m128i_op00) = 0x685670d37e80682a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x14ccc6320076a4d2; ++ *((unsigned long *)&__m128i_result0) = 0x685670d27e00682a; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00001b4a00007808; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0100010001000100; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000007fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000100; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x5d7f5d007f6a007f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fffefffe; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fffefffe; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x207fffff22bd04fb; ++ *((unsigned long *)&__m128i_op00) = 0x207fffff22bd04fb; ++ *((unsigned long *)&__m128i_op11) = 0x0001000002000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001000002000000; ++ *((unsigned long *)&__m128i_result1) = 0x207fffff22bd04fa; ++ *((unsigned long *)&__m128i_result0) = 0x207fffff22bd04fa; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffefffefffe; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op11) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000014; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00007fff7fff8000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000b81c8382; ++ *((unsigned long *)&__m128i_op10) = 0x0000000077af9450; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00007efe7f7f8000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000667ae56; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000004ff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000667ae56; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000020; ++ __m128i_out = __lsx_vbitclr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclri.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclri.c +new file mode 100644 +index 000000000..5d7d66e06 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitclri.c +@@ -0,0 +1,279 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_op00) = 0x000201000000000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_result0) = 0x000201000000000b; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_op00) = 0x004200a000200000; ++ *((unsigned long *)&__m128i_result1) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_result0) = 0x004200a000200000; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000efffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000002ff5; ++ *((unsigned long *)&__m128i_op00) = 0xc2cf2471e9b7d7a4; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000027f5; ++ *((unsigned long *)&__m128i_result0) = 0xc2cf2471e9b7d7a4; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7505443065413aed; ++ *((unsigned long *)&__m128i_op00) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_result1) = 0x7404443064403aec; ++ *((unsigned long *)&__m128i_result0) = 0x0000d6eefefc0498; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x36); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x64b680a2ae3af8ca; ++ *((unsigned long *)&__m128i_op00) = 0x161c0c363c200826; ++ *((unsigned long *)&__m128i_result1) = 0x64b680a2ae3af8c8; ++ *((unsigned long *)&__m128i_result0) = 0x161c0c363c200824; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xbfffbfffbfffbffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff807f807f807f80; ++ *((unsigned long *)&__m128i_op00) = 0xff807f807f807f80; ++ *((unsigned long *)&__m128i_result1) = 0xfb807b807b807b80; ++ *((unsigned long *)&__m128i_result0) = 0xfb807b807b807b80; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result0) = 0x1000100010001000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfbffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfbffffffffffffff; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x9941d1d5f4ba9d08; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x9941d155f43a9d08; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_result0) = 0xffffffbfffffffbf; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x03f1e3d28b1a8a1a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x03f1e3d28b1a8a1a; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffda6f; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffe3d7; ++ *((unsigned long *)&__m128i_result1) = 0xfefffffffeffda6f; ++ *((unsigned long *)&__m128i_result0) = 0xfefffffffeffe3d7; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x26); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x30); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080638063; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080638063; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op00) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result1) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result0) = 0x0004000400040004; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_d (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000200008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000200008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000200000; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200000001; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xdfdfdfdfdfdfdfdf; ++ *((unsigned long *)&__m128i_result0) = 0xdfdfdfdfdfdfdfdf; ++ __m128i_out = __lsx_vbitclri_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitclri_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrev.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrev.c +new file mode 100644 +index 000000000..ba4f4b6dc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrev.c +@@ -0,0 +1,407 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x1b71a083b3dec3cd; ++ *((unsigned long *)&__m128i_op10) = 0x373a13323b4cdbc1; ++ *((unsigned long *)&__m128i_result1) = 0x0802010808400820; ++ *((unsigned long *)&__m128i_result0) = 0x8004080408100802; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitrev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_result0) = 0x8000800080008000; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000501000002; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000008; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000040100; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010400100203; ++ *((unsigned long *)&__m128i_result0) = 0x0103010301020109; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffbe6ed563; ++ *((unsigned long *)&__m128i_op11) = 0xd0b1ffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x9d519ee8d2d84f1d; ++ *((unsigned long *)&__m128i_result1) = 0xfefd7f7f7f7f7f7e; ++ *((unsigned long *)&__m128i_result0) = 0xdffdbffeba6f5543; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7da9b23a624082fd; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x2002040404010420; ++ *((unsigned long *)&__m128i_result0) = 0x0101010180800101; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fffe0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001ffff0001fffe; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0e7ffffc01fffffc; ++ *((unsigned long *)&__m128i_op10) = 0x0000000003f803f4; ++ *((unsigned long *)&__m128i_result1) = 0x1000000010000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100100000; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_op00) = 0x040004000400040d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0501050105010501; ++ *((unsigned long *)&__m128i_result0) = 0x050105010501050c; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitrev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x000100010001fffe; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000007f00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7ffffffeffffffff; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0040000000400000; ++ *((unsigned long *)&__m128i_op00) = 0x0040000000400000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_result0) = 0x0141010101410101; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x65b780a3ae3bf8cb; ++ *((unsigned long *)&__m128i_op00) = 0x161d0c363c200826; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x65b780a2ae3bf8ca; ++ *((unsigned long *)&__m128i_result0) = 0x161d0c373c200827; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfe01fe01fe01fe01; ++ *((unsigned long *)&__m128i_result0) = 0xfe01fe01fe01fe01; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000003bfb4000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_op10) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000021ffffffdf; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000e60; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1ff85ffe2ae5d973; ++ *((unsigned long *)&__m128i_result1) = 0x00010020fffeffde; ++ *((unsigned long *)&__m128i_result0) = 0x0100400100200e68; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000001021; ++ *((unsigned long *)&__m128i_result1) = 0x0108020410400208; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010102; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff0000ff86; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x010101fe0101fe87; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x343d8dc5b0ed5a08; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x353c8cc4b1ec5b09; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0037ffc8d7ff2800; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff00ffffff00; ++ *((unsigned long *)&__m128i_op11) = 0x0038d800ff000000; ++ *((unsigned long *)&__m128i_op10) = 0x00fffe00fffffe00; ++ *((unsigned long *)&__m128i_result1) = 0x0137ffc9d7fe2801; ++ *((unsigned long *)&__m128i_result0) = 0x7f00ff017fffff01; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001200100012001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffe7fffffff; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010002; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000010000000; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_op00) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffdfffcfffdfffc; ++ *((unsigned long *)&__m128i_result0) = 0xfffdfffcfffdfffc; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001ffff0101ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0103fefd0303fefd; ++ *((unsigned long *)&__m128i_result0) = 0x0103fefd0103fefd; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x6a5d5b056f2f4978; ++ *((unsigned long *)&__m128i_op10) = 0x17483c07141b5971; ++ *((unsigned long *)&__m128i_result1) = 0x0000002001000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000008000020000; ++ __m128i_out = __lsx_vbitrev_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffefffefffe; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000001ce28f9c0; ++ *((unsigned long *)&__m128i_op10) = 0x00000004e06b0890; ++ *((unsigned long *)&__m128i_result1) = 0xfefefefdbffefdfe; ++ *((unsigned long *)&__m128i_result0) = 0xfefefeeffef7fefe; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x003ffffe00800000; ++ *((unsigned long *)&__m128i_result1) = 0xff810001ff810002; ++ *((unsigned long *)&__m128i_result0) = 0x7f804000ff810001; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff1affff01001fe0; ++ *((unsigned long *)&__m128i_op00) = 0xff1aff6d02834d70; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000034; ++ *((unsigned long *)&__m128i_result1) = 0xfe1bfefe00011ee1; ++ *((unsigned long *)&__m128i_result0) = 0xfe1bfe6c03824c60; ++ __m128i_out = __lsx_vbitrev_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x41945926d8000000; ++ *((unsigned long *)&__m128i_op11) = 0x00001e5410082727; ++ *((unsigned long *)&__m128i_op10) = 0x00007f7f00107f7f; ++ *((unsigned long *)&__m128i_result1) = 0x0001001001000080; ++ *((unsigned long *)&__m128i_result0) = 0x4195d926d8018000; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7f8100017f810001; ++ *((unsigned long *)&__m128i_result0) = 0x7f8100017f810001; ++ __m128i_out = __lsx_vbitrev_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x545501550001113a; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xd45501550001113a; ++ __m128i_out = __lsx_vbitrev_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrevi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrevi.c +new file mode 100644 +index 000000000..9739182cd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitrevi.c +@@ -0,0 +1,336 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000003004; ++ *((unsigned long *)&__m128i_result1) = 0x0000400000004000; ++ *((unsigned long *)&__m128i_result0) = 0x0000400000007004; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfeffffffffffffff; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x38); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4000400040004000; ++ *((unsigned long *)&__m128i_result0) = 0x4000400040004000; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000007fff8000; ++ *((unsigned long *)&__m128i_op00) = 0x0001008100000005; ++ *((unsigned long *)&__m128i_result1) = 0x0800080077ff8800; ++ *((unsigned long *)&__m128i_result0) = 0x0801088108000805; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0202020202020202; ++ *((unsigned long *)&__m128i_result0) = 0x0202020202020202; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xe86ce7eb5e9ce950; ++ *((unsigned long *)&__m128i_result1) = 0x0404040404040404; ++ *((unsigned long *)&__m128i_result0) = 0xec68e3ef5a98ed54; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_result1) = 0x0000400000004000; ++ *((unsigned long *)&__m128i_result0) = 0x0000400000204010; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x0400040004000400; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffff02; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x04000400fbfffb02; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010000000100000; ++ *((unsigned long *)&__m128i_result0) = 0x0010000000100000; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x040004000400040d; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000004f804f81; ++ *((unsigned long *)&__m128i_op00) = 0x000000004f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x000000004fc04f81; ++ *((unsigned long *)&__m128i_result0) = 0x000000004fc04f80; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_result0) = 0x0040004000400040; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x1010101010101010; ++ *((unsigned long *)&__m128i_result0) = 0xefefefefefefefef; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_result0) = 0x4040404040404040; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e1d1c1b1a; ++ *((unsigned long *)&__m128i_op00) = 0x1918171615141312; ++ *((unsigned long *)&__m128i_result1) = 0x01203f1e3d1c3b1a; ++ *((unsigned long *)&__m128i_result0) = 0x3918371635143312; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x61608654a2d4f6da; ++ *((unsigned long *)&__m128i_result1) = 0xfff0800080008000; ++ *((unsigned long *)&__m128i_result0) = 0xe160065422d476da; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x77c0401040004000; ++ *((unsigned long *)&__m128i_result0) = 0x77c0401040004000; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x77c0404a4000403a; ++ *((unsigned long *)&__m128i_op00) = 0x77c03fd640003fc6; ++ *((unsigned long *)&__m128i_result1) = 0x75c0404a4200403a; ++ *((unsigned long *)&__m128i_result0) = 0x75c03fd642003fc6; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808280808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808280808; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m128i_result0) = 0x00000100fffffeff; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0404050404040404; ++ *((unsigned long *)&__m128i_result0) = 0x0404050404040404; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result0) = 0x1000100010001000; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xbfbfbfbfbfbfbfbf; ++ *((unsigned long *)&__m128i_result0) = 0xbfbfbfbfbfbfbfbf; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000040000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000040000000; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000020000; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x2000200020002000; ++ *((unsigned long *)&__m128i_result0) = 0x2000200020002000; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x441ba9fcffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x181b2541ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x401fadf8fbfbfbfb; ++ *((unsigned long *)&__m128i_result0) = 0x1c1f2145fbfbfbfb; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffefff00001000; ++ *((unsigned long *)&__m128i_result0) = 0xffffefff00001000; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000000; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x21); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000002000; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000010000000100; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000100; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd6a09e662ab46b31; ++ *((unsigned long *)&__m128i_op00) = 0x34b8122ef4054bb3; ++ *((unsigned long *)&__m128i_result1) = 0xd6e09e262af46b71; ++ *((unsigned long *)&__m128i_result0) = 0x34f8126ef4454bf3; ++ __m128i_out = __lsx_vbitrevi_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000200008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000200000; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefefefdbffefdfe; ++ *((unsigned long *)&__m128i_op00) = 0xfefefeeffef7feff; ++ *((unsigned long *)&__m128i_result1) = 0xfcfcfcffbdfcfffc; ++ *((unsigned long *)&__m128i_result0) = 0xfcfcfcedfcf5fcfd; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000555889; ++ *((unsigned long *)&__m128i_op00) = 0x0000000002580f01; ++ *((unsigned long *)&__m128i_result1) = 0x0010000000455889; ++ *((unsigned long *)&__m128i_result0) = 0x0010000002480f01; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00060fbf00040fbf; ++ *((unsigned long *)&__m128i_op00) = 0x00020fbf00000fbf; ++ *((unsigned long *)&__m128i_result1) = 0x00060fbf02040fbf; ++ *((unsigned long *)&__m128i_result0) = 0x00020fbf02000fbf; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x400000003fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x4000000040000000; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x021b7d24c9678a35; ++ *((unsigned long *)&__m128i_op00) = 0x030298a6a1030a49; ++ *((unsigned long *)&__m128i_result1) = 0x00197f26cb658837; ++ *((unsigned long *)&__m128i_result0) = 0x01009aa4a301084b; ++ __m128i_out = __lsx_vbitrevi_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x3); ++ *((unsigned long *)&__m128i_op01) = 0x0000c6c60000c6c6; ++ *((unsigned long *)&__m128i_op00) = 0x8000c6c58000c6b2; ++ *((unsigned long *)&__m128i_result1) = 0x0000c6c40000c6c6; ++ *((unsigned long *)&__m128i_result0) = 0x8000c6c78000c6b2; ++ __m128i_out = __lsx_vbitrevi_d (__m128i_op0, 0x21); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffff7fffffff7f; ++ *((unsigned long *)&__m128i_result0) = 0xffffff7fffffff7f; ++ __m128i_out = __lsx_vbitrevi_w (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitsel.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitsel.c +new file mode 100644 +index 000000000..52ac9939f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitsel.c +@@ -0,0 +1,109 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000005050000; ++ *((unsigned long *)&__m128i_op00) = 0x0505000005050505; ++ *((unsigned long *)&__m128i_op11) = 0x000d02540000007e; ++ *((unsigned long *)&__m128i_op10) = 0x0000001400140014; ++ *((unsigned long *)&__m128i_op21) = 0x0505050505050505; ++ *((unsigned long *)&__m128i_op20) = 0x03574e38e496cbc9; ++ *((unsigned long *)&__m128i_result1) = 0x0005000400000004; ++ *((unsigned long *)&__m128i_result0) = 0x0400001001150404; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x0080001300000013; ++ *((unsigned long *)&__m128i_op00) = 0x0080001300000013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0080001300000013; ++ *((unsigned long *)&__m128i_result0) = 0x0080001300000013; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128i_op20) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_op00) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_op20) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op00) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_op11) = 0x62cbf96e4acfaf40; ++ *((unsigned long *)&__m128i_op10) = 0xf0bc9a5278285a4a; ++ *((unsigned long *)&__m128i_op21) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op20) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_result1) = 0x62cbf84c02cbac00; ++ *((unsigned long *)&__m128i_result0) = 0x1014120210280240; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff59; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff59; ++ __m128i_out = __lsx_vbitsel_v (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseli.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseli.c +new file mode 100644 +index 000000000..f2d6fb042 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseli.c +@@ -0,0 +1,84 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x6664666466646664; ++ *((unsigned long *)&__m128i_result0) = 0x6664666466646664; ++ __m128i_out = __lsx_vbitseli_b (__m128i_op0, __m128i_op1, 0x66); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op10) = 0xffffff0000010000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_result0) = 0x5d5d5d5d5d5d5d55; ++ __m128i_out = __lsx_vbitseli_b (__m128i_op0, __m128i_op1, 0x5d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0x5959595959595959; ++ *((unsigned long *)&__m128i_result0) = 0x5959595959595959; ++ __m128i_out = __lsx_vbitseli_b (__m128i_op0, __m128i_op1, 0x59); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitseli_b (__m128i_op0, __m128i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vbitseli_b (__m128i_op0, __m128i_op1, 0xaa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0b4c600000000002; ++ *((unsigned long *)&__m128i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op10) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0004280808080808; ++ __m128i_out = __lsx_vbitseli_b (__m128i_op0, __m128i_op1, 0xa4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000004000000040; ++ *((unsigned long *)&__m128i_op00) = 0x00007770ffff9411; ++ *((unsigned long *)&__m128i_op11) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_op10) = 0x00007770ffff941d; ++ *((unsigned long *)&__m128i_result1) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_result0) = 0x000047404f4f040d; ++ __m128i_out = __lsx_vbitseli_b (__m128i_op0, __m128i_op1, 0x4f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitset.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitset.c +new file mode 100644 +index 000000000..e05af675e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitset.c +@@ -0,0 +1,371 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op00) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffe001ffffe001; ++ *((unsigned long *)&__m128i_result0) = 0xffffe001ffffe001; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000038335ca2777; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000800800000; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf51cf8dad6040188; ++ *((unsigned long *)&__m128i_op00) = 0x0982e2daf234ed87; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xf51df8dbd6050189; ++ *((unsigned long *)&__m128i_result0) = 0x0983e2dbf235ed87; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfc01fcfefc02fdf7; ++ *((unsigned long *)&__m128i_op00) = 0xfe00fcfffe01fd01; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op10) = 0x5d5d5d5d5d5d5d55; ++ *((unsigned long *)&__m128i_result1) = 0xfc01fcfefc02fdf7; ++ *((unsigned long *)&__m128i_result0) = 0xfe00fcfffe21fd01; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fff7fc01; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x80000000fff7fc01; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffe00000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff01010105; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001c00ffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0101010201808040; ++ *((unsigned long *)&__m128i_result0) = 0x0101010280808040; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3f8000003f800001; ++ *((unsigned long *)&__m128i_result0) = 0x3f8000003f800001; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000010a000b; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000104000800; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000897957687; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000408; ++ *((unsigned long *)&__m128i_result1) = 0x0000010000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000100; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_op10) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000002; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff994cb09c; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffc3639d96; ++ *((unsigned long *)&__m128i_op11) = 0x20de27761210386d; ++ *((unsigned long *)&__m128i_op10) = 0x34632935195a123c; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff994db09c; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffc7639d96; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000545cab1d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000081a83bea; ++ *((unsigned long *)&__m128i_op11) = 0x13f9c5b60028a415; ++ *((unsigned long *)&__m128i_op10) = 0x545cab1d81a83bea; ++ *((unsigned long *)&__m128i_result1) = 0x00400000547cab1d; ++ *((unsigned long *)&__m128i_result0) = 0x2000000081a83fea; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000038003; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000040033; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100080000; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op10) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result1) = 0x0909090909090909; ++ *((unsigned long *)&__m128i_result0) = 0x0909090909090909; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00a600e000a600e0; ++ *((unsigned long *)&__m128i_op10) = 0x01500178010000f8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0100000001000000; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfefbff06fffa0004; ++ *((unsigned long *)&__m128i_op10) = 0xfefeff04fffd0004; ++ *((unsigned long *)&__m128i_result1) = 0x4008804080040110; ++ *((unsigned long *)&__m128i_result0) = 0x4040801080200110; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x8101010181010101; ++ *((unsigned long *)&__m128i_result0) = 0x8101010181010101; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101030101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101030101; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd78cfd70b5f65d76; ++ *((unsigned long *)&__m128i_op00) = 0x5779108fdedda7e4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xd78cfd70b5f65d77; ++ *((unsigned long *)&__m128i_result0) = 0x5779108fdedda7e5; ++ __m128i_out = __lsx_vbitset_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x00004a1e00004a1e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_result0) = 0x4000000040000000; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0007000000050000; ++ *((unsigned long *)&__m128i_op10) = 0x0003000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0080000100200001; ++ *((unsigned long *)&__m128i_result0) = 0x0008000200020002; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff80ffff7e02; ++ *((unsigned long *)&__m128i_op00) = 0x00feff8000ff80ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0280000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffff81ffff7f03; ++ *((unsigned long *)&__m128i_result0) = 0x04ffff8101ff81ff; ++ __m128i_out = __lsx_vbitset_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4480000044800000; ++ *((unsigned long *)&__m128i_op00) = 0x45c0000044800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00fe00fe7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x4481000144810001; ++ *((unsigned long *)&__m128i_result0) = 0x45c04000c4808000; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x3bc000003a800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00fe00fe7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x3a8100013a810001; ++ *((unsigned long *)&__m128i_result0) = 0x7bc04000ba808000; ++ __m128i_out = __lsx_vbitset_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000cecd00004657; ++ *((unsigned long *)&__m128i_op10) = 0x0000c90000011197; ++ *((unsigned long *)&__m128i_result1) = 0x0000200000800000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100800000; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op10) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result1) = 0x7f8000017f800001; ++ *((unsigned long *)&__m128i_result0) = 0x7f8000017f800001; ++ __m128i_out = __lsx_vbitset_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseti.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseti.c +new file mode 100644 +index 000000000..540a724a7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vbitseti.c +@@ -0,0 +1,279 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_result0) = 0x0020002000200020; ++ __m128i_out = __lsx_vbitseti_h (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0040000000ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x0040000000000000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x36); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x54beed87bc3f2be1; ++ *((unsigned long *)&__m128i_op00) = 0x8024d8f6a494afcb; ++ *((unsigned long *)&__m128i_result1) = 0x54feed87bc3f2be1; ++ *((unsigned long *)&__m128i_result0) = 0x8064d8f6a494afcb; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x36); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000c400; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x001000100010c410; ++ __m128i_out = __lsx_vbitseti_h (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2e2b34ca59fa4c88; ++ *((unsigned long *)&__m128i_op00) = 0x3b2c8aefd44be966; ++ *((unsigned long *)&__m128i_result1) = 0x3e2b34ca59fa4c88; ++ *((unsigned long *)&__m128i_result0) = 0x3b2c8aefd44be966; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_result1) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_result0) = 0x0040004017fda869; ++ __m128i_out = __lsx_vbitseti_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x800000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x800000ff080000ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000000010000; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0004000000040000; ++ *((unsigned long *)&__m128i_result0) = 0x0004000000040000; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vbitseti_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf51cf8dad6040188; ++ *((unsigned long *)&__m128i_op00) = 0x0982e2daf234ed87; ++ *((unsigned long *)&__m128i_result1) = 0xf51cf8dad6040188; ++ *((unsigned long *)&__m128i_result0) = 0x0982eadaf234ed87; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0002000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000000000000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x31); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000006; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000006; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000080000000000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x000000010000003f; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x000000030000003f; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe5e5e5e5e5e5e5e5; ++ *((unsigned long *)&__m128i_op00) = 0xe5e5e5e5e4e4e46d; ++ *((unsigned long *)&__m128i_result1) = 0xe5e5e5e5e5e5e5e5; ++ *((unsigned long *)&__m128i_result0) = 0xe5e5e5e5e4e4e46d; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vbitseti_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result0) = 0x1000100010001000; ++ __m128i_out = __lsx_vbitseti_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_result0) = 0x0800080008000800; ++ __m128i_out = __lsx_vbitseti_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0100000001000000; ++ *((unsigned long *)&__m128i_result0) = 0x0100000001000000; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_result1) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_result0) = 0x2020202020207fff; ++ __m128i_out = __lsx_vbitseti_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000900000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000900013fa0; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x23); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x40f3fa0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3ff0008000800080; ++ *((unsigned long *)&__m128i_result0) = 0x40f3fa8000800080; ++ __m128i_out = __lsx_vbitseti_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000040000000000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0404040404040404; ++ *((unsigned long *)&__m128i_result0) = 0xc404040404040404; ++ __m128i_out = __lsx_vbitseti_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000040804000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000040804000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000040a04000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000040a04000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x1f81e3779b97f4a8; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff02000000; ++ *((unsigned long *)&__m128i_result0) = 0x1f81e3779b97f4a8; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000008000000080; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0100010001000101; ++ *((unsigned long *)&__m128i_result0) = 0x0100010001000101; ++ __m128i_out = __lsx_vbitseti_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vbitseti_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000010000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000010000000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002711250a27112; ++ *((unsigned long *)&__m128i_op00) = 0x00d2701294027112; ++ *((unsigned long *)&__m128i_result1) = 0x080a791a58aa791a; ++ *((unsigned long *)&__m128i_result0) = 0x08da781a9c0a791a; ++ __m128i_out = __lsx_vbitseti_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_op00) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_result1) = 0x1313131313131313; ++ *((unsigned long *)&__m128i_result0) = 0x1313131313131313; ++ __m128i_out = __lsx_vbitseti_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000000000000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x30); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000000; ++ __m128i_out = __lsx_vbitseti_d (__m128i_op0, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfff0008000000080; ++ *((unsigned long *)&__m128i_result0) = 0xfff0008000000080; ++ __m128i_out = __lsx_vbitseti_w (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclo.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclo.c +new file mode 100644 +index 000000000..2c1099a04 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclo.c +@@ -0,0 +1,266 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_op00) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vclo_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe2ecd48adedc7c82; ++ *((unsigned long *)&__m128i_op00) = 0x25d666472b01d18d; ++ *((unsigned long *)&__m128i_result1) = 0x0303020102020001; ++ *((unsigned long *)&__m128i_result0) = 0x0002000000000201; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000fefefe6a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c2bac2c2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000007070700; ++ *((unsigned long *)&__m128i_result0) = 0x0000000002010202; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m128i_op00) = 0x3d3d3d3d3d3d3d3d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000007e8a60; ++ *((unsigned long *)&__m128i_op00) = 0x000000000001edde; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x05d0ae6002e8748e; ++ *((unsigned long *)&__m128i_op00) = 0xcd1de80217374041; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000001fffff59; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000aaaa; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0xffffe500ffffc085; ++ *((unsigned long *)&__m128i_op00) = 0xffffc000ffffc005; ++ *((unsigned long *)&__m128i_result1) = 0x0000001300000012; ++ *((unsigned long *)&__m128i_result0) = 0x0000001200000012; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001000000000; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000a00000009; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x413e276583869d79; ++ *((unsigned long *)&__m128i_op00) = 0x7f7f017f9d8726d3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m128i_op00) = 0xc090380000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000200000000d; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000000; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010012; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fec20704; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclo_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m128i_result1) = 0x000000200000001c; ++ *((unsigned long *)&__m128i_result0) = 0x000000200000001c; ++ __m128i_out = __lsx_vclo_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclz.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclz.c +new file mode 100644 +index 000000000..12df2c670 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vclz.c +@@ -0,0 +1,265 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010000800100008; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000001fc1a568; ++ *((unsigned long *)&__m128i_op00) = 0x02693fe0e7beb077; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000030000; ++ *((unsigned long *)&__m128i_result0) = 0x0006000200000000; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f7f000b000b000b; ++ *((unsigned long *)&__m128i_op00) = 0x000b000b010a000b; ++ *((unsigned long *)&__m128i_result1) = 0x0101080408040804; ++ *((unsigned long *)&__m128i_result0) = 0x0804080407040804; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1ffffffff8001000; ++ *((unsigned long *)&__m128i_op00) = 0xf0bd80bd80bd8000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010000fe7c; ++ *((unsigned long *)&__m128i_op00) = 0x000100010000fe01; ++ *((unsigned long *)&__m128i_result1) = 0x000f000f00100000; ++ *((unsigned long *)&__m128i_result0) = 0x000f000f00100000; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x41dfffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0100000008080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vclz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000039; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000039; ++ __m128i_out = __lsx_vclz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff000100ff00fe; ++ *((unsigned long *)&__m128i_op00) = 0x00ff003000ff00a0; ++ *((unsigned long *)&__m128i_result1) = 0x0008000f00080008; ++ *((unsigned long *)&__m128i_result0) = 0x0008000a00080008; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe813f00fe813f00; ++ *((unsigned long *)&__m128i_op00) = 0xfe813f00fe813f00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000002; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000bffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vclz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000c0c00000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vclz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x687a8373f249bc44; ++ *((unsigned long *)&__m128i_op00) = 0x7861145d9241a14a; ++ *((unsigned long *)&__m128i_result1) = 0x0101000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0101030100010001; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vclz_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080700000000; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000f0000000f; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_op00) = 0x000000008000001e; ++ *((unsigned long *)&__m128i_result1) = 0x000000200000001b; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000000; ++ __m128i_out = __lsx_vclz_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080805; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080805; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vclz_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000000000; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vclz_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpcnt.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpcnt.c +new file mode 100644 +index 000000000..66982d89f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vpcnt.c +@@ -0,0 +1,350 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x7); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffefefefe; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000003c; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000800000008; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0701000007010000; ++ *((unsigned long *)&__m128i_result0) = 0x0701000000000000; ++ __m128i_out = __lsx_vpcnt_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x807f7f8000ffff00; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff00feff00; ++ *((unsigned long *)&__m128i_result1) = 0x0107070100080800; ++ *((unsigned long *)&__m128i_result0) = 0x0000080800070800; ++ __m128i_out = __lsx_vpcnt_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op00) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_result1) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_result0) = 0x0303030303030303; ++ __m128i_out = __lsx_vpcnt_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000100010; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128i_op00) = 0x803f800080000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000e; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000009; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0003000000010000; ++ *((unsigned long *)&__m128i_result1) = 0x0003000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000000010000; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_op00) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0ba00ba00ba00ba0; ++ *((unsigned long *)&__m128i_op00) = 0x0ba00ba00ba011eb; ++ *((unsigned long *)&__m128i_result1) = 0x0000000a0000000a; ++ *((unsigned long *)&__m128i_result0) = 0x0000000a0000000d; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfbfbfb17fbfb38ea; ++ *((unsigned long *)&__m128i_op00) = 0xfbfb47fbfbfb0404; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000002f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000029; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffbfc0ffffbfc0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000032; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e19181716; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0003000900050007; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000002; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff0800080008000; ++ *((unsigned long *)&__m128i_op00) = 0xe160065422d476da; ++ *((unsigned long *)&__m128i_result1) = 0x0000000d00000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000b00000010; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_result0) = 0x0000001000000000; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_op00) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000002; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vpcnt_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x0103000201030002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000008; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x000000200000001e; ++ *((unsigned long *)&__m128i_result0) = 0x000000200000001e; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbbe5560400010001; ++ *((unsigned long *)&__m128i_op00) = 0xe7e5dabf00010001; ++ *((unsigned long *)&__m128i_result1) = 0x000b000500010001; ++ *((unsigned long *)&__m128i_result0) = 0x000b000c00010001; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000001f0000001f; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000020; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000600007fff; ++ *((unsigned long *)&__m128i_op00) = 0x00000008ffffa209; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000016; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000467fef81; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000013; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000fe03fe01; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fe01fe01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000007020701; ++ *((unsigned long *)&__m128i_result0) = 0x0000000007010701; ++ __m128i_out = __lsx_vpcnt_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f80000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf654ad7447e59090; ++ *((unsigned long *)&__m128i_op00) = 0x27b1b106b8145f50; ++ *((unsigned long *)&__m128i_result1) = 0x000000120000000d; ++ *((unsigned long *)&__m128i_result0) = 0x0000000e0000000e; ++ __m128i_out = __lsx_vpcnt_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vdiv-vmod-instruct.patch
Added
@@ -0,0 +1,1114 @@ +From 1a3f6886143b0fd334d1d7530bce0a746b106b27 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 18:51:44 +0800 +Subject: PATCH 088/124 LoongArch: Add tests for SX vector vdiv/vmod + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vdiv-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vdiv-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmod-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmod-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vdiv-1.c | 299 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vdiv-2.c | 254 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vmod-1.c | 254 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vmod-2.c | 254 +++++++++++++++ + 4 files changed, 1061 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-1.c +new file mode 100644 +index 000000000..cb4be0475 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-1.c +@@ -0,0 +1,299 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x40f3fa0000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_result1) = 0xc110000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xc00d060000000000; ++ __m128i_out = __lsx_vdiv_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vdiv_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x0101000101010001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000fe0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff00ffffff00ff; ++ __m128i_out = __lsx_vdiv_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0101010100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101010100000000; ++ __m128i_out = __lsx_vdiv_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op10) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff9727ffff9727; ++ *((unsigned long *)&__m128i_op00) = 0xfffffe79ffffba5f; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x010169d9010169d9; ++ *((unsigned long *)&__m128i_result0) = 0x01010287010146a1; ++ __m128i_out = __lsx_vdiv_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000897957687; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000408; ++ *((unsigned long *)&__m128i_op11) = 0x80010001b57fc565; ++ *((unsigned long *)&__m128i_op10) = 0x8001000184000be0; ++ *((unsigned long *)&__m128i_result1) = 0x000000080001fffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff9cf0d77b; ++ *((unsigned long *)&__m128i_op10) = 0xc1000082b0fb585b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op11) = 0x33f5c2d7d975d7fe; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff010000ff01; ++ __m128i_out = __lsx_vdiv_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000feff23560000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fd1654860000; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363abdf16; ++ *((unsigned long *)&__m128i_op10) = 0x41f8e08016161198; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000030000; ++ __m128i_out = __lsx_vdiv_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op10) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00003ff000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fffc00000000; ++ *((unsigned long *)&__m128i_op11) = 0x00001ff800000001; ++ *((unsigned long *)&__m128i_op10) = 0x7ffe800e80000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x195f307a5d04acbb; ++ *((unsigned long *)&__m128i_op00) = 0x6a1a3fbb3c90260e; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xe6a0cf86a2fb5345; ++ *((unsigned long *)&__m128i_result0) = 0x95e5c045c36fd9f2; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000fffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0010000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op10) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa2e3a36363636363; ++ *((unsigned long *)&__m128i_op00) = 0xa2e3a36463636363; ++ *((unsigned long *)&__m128i_op11) = 0x7f80000000000007; ++ *((unsigned long *)&__m128i_op10) = 0x0000000700000007; ++ *((unsigned long *)&__m128i_result1) = 0x000000000e32c50e; ++ *((unsigned long *)&__m128i_result0) = 0xf2b2ce330e32c50e; ++ __m128i_out = __lsx_vdiv_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000001; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op00) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op11) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op10) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xe93d0bd19ff0c170; ++ *((unsigned long *)&__m128i_op10) = 0x5237c1bac9eadf55; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op10) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_result1) = 0x00000001084314a6; ++ *((unsigned long *)&__m128i_result0) = 0x00000001084314a6; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000ffef0010000; ++ *((unsigned long *)&__m128i_op11) = 0x0000010000010101; ++ *((unsigned long *)&__m128i_op10) = 0x0101000001000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x4280000042800000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xbd7fffffbd800000; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op11) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_op10) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000004ff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000667ae56; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000020; ++ __m128i_out = __lsx_vdiv_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-2.c +new file mode 100644 +index 000000000..f2bc7df27 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vdiv-2.c +@@ -0,0 +1,254 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_op10) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xe3e3e3e3e3e3e3e3; ++ *((unsigned long *)&__m128i_op11) = 0xe3e3e3e3e3e3e3e3; ++ *((unsigned long *)&__m128i_op10) = 0xe3e3e3e3e3e3e3e3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vdiv_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vdiv_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_op11) = 0x31b1777777777776; ++ *((unsigned long *)&__m128i_op10) = 0x6eee282828282829; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vdiv_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_op00) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0effeffefdffa1e0; ++ *((unsigned long *)&__m128i_op00) = 0xe6004c5f64284224; ++ *((unsigned long *)&__m128i_op11) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfeffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_op10) = 0x203e16d116de012b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000073; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000002a; ++ *((unsigned long *)&__m128i_op11) = 0x00ffffff00ff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000003f200001e01; ++ *((unsigned long *)&__m128i_op00) = 0x000014bf000019da; ++ *((unsigned long *)&__m128i_op11) = 0x9c9c99aed5b88fcf; ++ *((unsigned long *)&__m128i_op10) = 0x7c3650c5f79a61a3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080800008; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffd700; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vdiv_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffffdfffdf; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffbfff8; ++ *((unsigned long *)&__m128i_op11) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_op10) = 0x0080006b0000000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000001ff1745745c; ++ __m128i_out = __lsx_vdiv_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff14eb54ab; ++ *((unsigned long *)&__m128i_op00) = 0x14ea6a002a406a00; ++ *((unsigned long *)&__m128i_op11) = 0xffff80008a7555aa; ++ *((unsigned long *)&__m128i_op10) = 0x0a7535006af05cf9; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000000; ++ __m128i_out = __lsx_vdiv_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_op00) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_op11) = 0xfebffefffebffeff; ++ *((unsigned long *)&__m128i_op10) = 0xfebffefffebffeff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363797c63996399; ++ *((unsigned long *)&__m128i_op00) = 0x171f0a1f6376441f; ++ *((unsigned long *)&__m128i_op11) = 0x6363797c63996399; ++ *((unsigned long *)&__m128i_op10) = 0x171f0a1f6376441f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vdiv_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000036de0000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003be14000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_result1) = 0x00000000007e8a60; ++ *((unsigned long *)&__m128i_result0) = 0x000000000001edde; ++ __m128i_out = __lsx_vdiv_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000015d926c7; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000e41b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x77c0404a4000403a; ++ *((unsigned long *)&__m128i_op00) = 0x77c03fd640003fc6; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vdiv_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0042003e0042002f; ++ *((unsigned long *)&__m128i_op00) = 0x0001fffc0001fffc; ++ *((unsigned long *)&__m128i_op11) = 0x0042003e0042002f; ++ *((unsigned long *)&__m128i_op10) = 0x0001fffc0001fffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vdiv_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000feff2356; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fd165486; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000007; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000007; ++ *((unsigned long *)&__m128i_result1) = 0x00000000246d9755; ++ *((unsigned long *)&__m128i_result0) = 0x000000002427c2ee; ++ __m128i_out = __lsx_vdiv_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-1.c +new file mode 100644 +index 000000000..5470d40dd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-1.c +@@ -0,0 +1,254 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x82c539ffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xc72df14afbfafdf9; ++ *((unsigned long *)&__m128i_op11) = 0x82c539ffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xc72df14afbfafdf9; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff994cb09c; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffc3639d96; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0003c853c843c844; ++ *((unsigned long *)&__m128i_op00) = 0x0003c853c843c844; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001808281820102; ++ *((unsigned long *)&__m128i_op00) = 0x0001808201018081; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0001008281820102; ++ *((unsigned long *)&__m128i_result0) = 0x0001008201010081; ++ __m128i_out = __lsx_vmod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0101010240010202; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op11) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op10) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000104000800; ++ *((unsigned long *)&__m128i_op11) = 0x0101080408040804; ++ *((unsigned long *)&__m128i_op10) = 0x0804080407040804; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000104000800; ++ __m128i_out = __lsx_vmod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op11) = 0x1202120212021202; ++ *((unsigned long *)&__m128i_op10) = 0x1202120212021202; ++ *((unsigned long *)&__m128i_result1) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result0) = 0x1000100010001000; ++ __m128i_out = __lsx_vmod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vmod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_op00) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_op11) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_op10) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfeca2eb9931; ++ *((unsigned long *)&__m128i_op11) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op10) = 0x370bdfeca2eb9931; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x805ffffe01001fe0; ++ *((unsigned long *)&__m128i_op00) = 0x9a49e11102834d70; ++ *((unsigned long *)&__m128i_op11) = 0x8144ffff01c820a4; ++ *((unsigned long *)&__m128i_op10) = 0x9b2ee1a4034b4e34; ++ *((unsigned long *)&__m128i_result1) = 0xff1affff01001fe0; ++ *((unsigned long *)&__m128i_result0) = 0xff1aff6d02834d70; ++ __m128i_out = __lsx_vmod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001d001d001d001d; ++ *((unsigned long *)&__m128i_op00) = 0x001d001d001d0000; ++ *((unsigned long *)&__m128i_op11) = 0x001d001d001d001d; ++ *((unsigned long *)&__m128i_op10) = 0x001d001d001d0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_op10) = 0x4f8000004f800000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ffff000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x03c0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x03c0038000000380; ++ *((unsigned long *)&__m128i_result1) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ffff000000ff00; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op10) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80000000307d0771; ++ *((unsigned long *)&__m128i_op00) = 0x0d8e36706ac02b9b; ++ *((unsigned long *)&__m128i_op11) = 0x80000000307d0771; ++ *((unsigned long *)&__m128i_op10) = 0x0d8e36706ac02b9b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x413e276583869d79; ++ *((unsigned long *)&__m128i_op10) = 0x7f7f017f9d8726d3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000011ffee; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000dfff2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-2.c +new file mode 100644 +index 000000000..8deb04427 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmod-2.c +@@ -0,0 +1,254 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x16161616a16316b0; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x16161616a16316b0; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x5a5a5a5a5b5a5b5a; ++ *((unsigned long *)&__m128i_op10) = 0x5a5a5a5a5b5a5b5a; ++ *((unsigned long *)&__m128i_result1) = 0x00000001494b494a; ++ *((unsigned long *)&__m128i_result0) = 0x00000001494b494a; ++ __m128i_out = __lsx_vmod_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_op10) = 0xa352bfac9269e0aa; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffeb; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffeb; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f801fa06451ef11; ++ *((unsigned long *)&__m128i_op10) = 0x68bcf93435ed25ed; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000022666621; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffdd9999da; ++ *((unsigned long *)&__m128i_op11) = 0x7f7f7f7f00107f04; ++ *((unsigned long *)&__m128i_op10) = 0x7f0000fd7f0000fd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000066621; ++ *((unsigned long *)&__m128i_result0) = 0x01ff00085e9900ab; ++ __m128i_out = __lsx_vmod_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000bd3d; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fff0000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xefffdffff0009d3d; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000bd3d; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fff0000; ++ __m128i_out = __lsx_vmod_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000004870ba0; ++ *((unsigned long *)&__m128i_op11) = 0x478b478b38031779; ++ *((unsigned long *)&__m128i_op10) = 0x6b769e690fa1e119; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000004870ba0; ++ __m128i_out = __lsx_vmod_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_op00) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_op11) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_op10) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op11) = 0x02b010f881a281a2; ++ *((unsigned long *)&__m128i_op10) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200020002; ++ __m128i_out = __lsx_vmod_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff100000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op10) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000f000000000000; ++ __m128i_out = __lsx_vmod_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fffe0000fffe; ++ *((unsigned long *)&__m128i_op11) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m128i_op10) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fffe0000fffe; ++ __m128i_out = __lsx_vmod_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000101fd01fe; ++ *((unsigned long *)&__m128i_op11) = 0xff80ff80ff80ff80; ++ *((unsigned long *)&__m128i_op10) = 0xff80ff8080008000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000101fd01fe; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffcafff8ff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000a0; ++ *((unsigned long *)&__m128i_op11) = 0xff2cfed4fea8ff44; ++ *((unsigned long *)&__m128i_op10) = 0xfffeffff0035ff8f; ++ *((unsigned long *)&__m128i_result1) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000a0; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op10) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result1) = 0x0003c853c843c844; ++ *((unsigned long *)&__m128i_result0) = 0x0003c853c843c844; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_op11) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_op10) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000003ddc5dac; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffefffff784; ++ *((unsigned long *)&__m128i_op11) = 0x10f8000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x00000001000010f8; ++ *((unsigned long *)&__m128i_result1) = 0x0177fff0fffffff0; ++ *((unsigned long *)&__m128i_result0) = 0x00000000011ff8bc; ++ __m128i_out = __lsx_vmod_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vexth-vextl-vldi-v.patch
Added
@@ -0,0 +1,1664 @@ +From ed55869f2ae380ac36d09746e7e04ce675e197b0 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 18:44:16 +0800 +Subject: PATCH 086/124 LoongArch: Add tests for SX vector + vexth/vextl/vldi/vneg/vsat instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vexth-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vexth-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vextl-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vextl-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vldi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vneg.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsat-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsat-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vexth-1.c | 342 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vexth-2.c | 182 ++++++++++ + .../loongarch/vector/lsx/lsx-vextl-1.c | 83 +++++ + .../loongarch/vector/lsx/lsx-vextl-2.c | 83 +++++ + .../loongarch/vector/lsx/lsx-vldi.c | 61 ++++ + .../loongarch/vector/lsx/lsx-vneg.c | 321 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vsat-1.c | 231 ++++++++++++ + .../loongarch/vector/lsx/lsx-vsat-2.c | 272 ++++++++++++++ + 8 files changed, 1575 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vldi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vneg.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-1.c +new file mode 100644 +index 000000000..f6390800d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-1.c +@@ -0,0 +1,342 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000f909; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1010111105050000; ++ *((unsigned long *)&__m128i_op00) = 0x4040000041410101; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000110011; ++ *((unsigned long *)&__m128i_result0) = 0x0005000500000000; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000003e2; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000003ffe2; ++ __m128i_out = __lsx_vexth_h_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffe; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00003ff000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03c0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x03c0038000000380; ++ *((unsigned long *)&__m128i_result1) = 0x000003c000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xb9fe3640e4eb1b18; ++ *((unsigned long *)&__m128i_op00) = 0x800000005b4b1b18; ++ *((unsigned long *)&__m128i_result1) = 0xffffb9fe00003640; ++ *((unsigned long *)&__m128i_result0) = 0xffffe4eb00001b18; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfec00130014; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfec00130014; ++ *((unsigned long *)&__m128i_result1) = 0x0000370bffffdfec; ++ *((unsigned long *)&__m128i_result0) = 0x0000001300000014; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe500c085c000c005; ++ *((unsigned long *)&__m128i_op00) = 0xe5c1a185c48004c5; ++ *((unsigned long *)&__m128i_result1) = 0xffffe500ffffc085; ++ *((unsigned long *)&__m128i_result0) = 0xffffc000ffffc005; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_w_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5c9c9c9ce3636363; ++ *((unsigned long *)&__m128i_op00) = 0x63635c9e63692363; ++ *((unsigned long *)&__m128i_result1) = 0x000000005c9c9c9c; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffe3636363; ++ __m128i_out = __lsx_vexth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x63b2ac27aa076aeb; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000063b2ac27; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffaa076aeb; ++ __m128i_out = __lsx_vexth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x002a001a001a000b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000002a001a; ++ *((unsigned long *)&__m128i_result0) = 0x00000000001a000b; ++ __m128i_out = __lsx_vexth_d_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0028280000000000; ++ *((unsigned long *)&__m128i_op00) = 0x012927ffff272800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0028280000000000; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff000000ff; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000020000020; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000fff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffc; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000080; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3a8000003a800000; ++ __m128i_out = __lsx_vexth_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-2.c +new file mode 100644 +index 000000000..6ab217e97 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vexth-2.c +@@ -0,0 +1,182 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x004f0080004f0080; ++ *((unsigned long *)&__m128i_result0) = 0x004f0080004f0080; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff007f00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff007f00000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff0000007f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0x5); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007fffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x002cffacffacffab; ++ *((unsigned long *)&__m128i_result1) = 0x0000007f00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vexth_hu_bu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000082020201; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000820200000201; ++ __m128i_out = __lsx_vexth_wu_hu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010012; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fec20704; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000012; ++ __m128i_out = __lsx_vexth_wu_hu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vexth_du_wu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_du_wu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_du_wu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_du_wu (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000001; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000b5207f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fff7fc01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x000001fc00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000000020000; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000b4a00008808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080800000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000b4a00008808; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000400080003fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000bc2000007e10; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000400080003fff; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vexth_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-1.c +new file mode 100644 +index 000000000..99854dbd8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-1.c +@@ -0,0 +1,83 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000170014; ++ *((unsigned long *)&__m128i_op00) = 0xff0cff78ff96ff14; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xff0cff78ff96ff14; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe500ffffc085; ++ *((unsigned long *)&__m128i_op00) = 0xffffc000ffffc005; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffc000ffffc005; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000000000; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3131313131313131; ++ *((unsigned long *)&__m128i_op00) = 0x3131313131313131; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3131313131313131; ++ __m128i_out = __lsx_vextl_q_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-2.c +new file mode 100644 +index 000000000..73bb530c9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vextl-2.c +@@ -0,0 +1,83 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000101fffff8b68; ++ *((unsigned long *)&__m128i_op00) = 0x00000b6fffff8095; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000b6fffff8095; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000104000800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000104000800; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010000fe7c; ++ *((unsigned long *)&__m128i_op00) = 0x000100010000fe01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000100010000fe01; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xc8847ef6ed3f2000; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x33f5c2d7d975d7fe; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000d82; ++ *((unsigned long *)&__m128i_op00) = 0x046a09ec009c0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x046a09ec009c0000; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vextl_qu_du (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vldi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vldi.c +new file mode 100644 +index 000000000..089500ea9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vldi.c +@@ -0,0 +1,61 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_result1) = 0x00a300a300a300a3; ++ *((unsigned long *)&__m128i_result0) = 0x00a300a300a300a3; ++ __m128i_out = __lsx_vldi (1187); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffe15; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffe15; ++ __m128i_out = __lsx_vldi (3605); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_result1) = 0xecececececececec; ++ *((unsigned long *)&__m128i_result0) = 0xecececececececec; ++ __m128i_out = __lsx_vldi (1004); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_result1) = 0x00ffff00ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0x00ffff00ff00ff00; ++ __m128i_out = __lsx_vldi (-1686); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x3); ++ *((unsigned long *)&__m128i_result1) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_result0) = 0x004d004d004d004d; ++ __m128i_out = __lsx_vldi (1101); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_result1) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_result0) = 0x0a0000000a000000; ++ __m128i_out = __lsx_vldi (-3318); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_result1) = 0x00ffff00ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0x00ffff00ff00ff00; ++ __m128i_out = __lsx_vldi (-1686); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_result1) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_result0) = 0x0a0000000a000000; ++ __m128i_out = __lsx_vldi (-3318); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vneg.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vneg.c +new file mode 100644 +index 000000000..9441ba50e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vneg.c +@@ -0,0 +1,321 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffeffffffff; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffefffffffc; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffff00ffffff01; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000fff3; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff0001ffffff0a; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100000101; ++ *((unsigned long *)&__m128i_result0) = 0x000100ff010101f6; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff000000ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0100000001000100; ++ *((unsigned long *)&__m128i_result0) = 0x0100010000000000; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000101; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000fffffeff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffbff8888080a; ++ *((unsigned long *)&__m128i_op00) = 0x080803ff807ff7f9; ++ *((unsigned long *)&__m128i_result1) = 0x010105017878f8f6; ++ *((unsigned long *)&__m128i_result0) = 0xf8f8fd0180810907; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000300000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100010001; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffdffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffeffff; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x441ba9fcffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x181b2541ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xbbe5560400010001; ++ *((unsigned long *)&__m128i_result0) = 0xe7e5dabf00010001; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000060a3db; ++ *((unsigned long *)&__m128i_op00) = 0xa70594c000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ff9f5c25; ++ *((unsigned long *)&__m128i_result0) = 0x58fa6b4000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vneg_b (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_op00) = 0x000000008000001e; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffe1; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff7fffffe2; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_result0) = 0x377b810912c0e000; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffc00001ff800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x003ffffe00800000; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100000000; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vneg_h (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x087c000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000087c; ++ *((unsigned long *)&__m128i_result1) = 0xf784000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffff784; ++ __m128i_out = __lsx_vneg_d (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vneg_w (__m128i_op0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-1.c +new file mode 100644 +index 000000000..cd8eefb47 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-1.c +@@ -0,0 +1,231 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xf000000000000000; ++ __m128i_out = __lsx_vsat_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsat_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_result1) = 0x03ff0101fc010102; ++ *((unsigned long *)&__m128i_result0) = 0x03fffffffc010102; ++ __m128i_out = __lsx_vsat_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsat_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000040400000383; ++ *((unsigned long *)&__m128i_op00) = 0xffff8383ffff7d0d; ++ *((unsigned long *)&__m128i_result1) = 0x0000040400000383; ++ *((unsigned long *)&__m128i_result0) = 0xffffe000ffff1fff; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff8f8da00; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff01018888; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00ffff00; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f8000003f800001; ++ *((unsigned long *)&__m128i_op00) = 0x3f8000003f800001; ++ *((unsigned long *)&__m128i_result1) = 0x0001000000010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000000010001; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_result0) = 0x0000c000ffffc000; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0038d800ff000000; ++ *((unsigned long *)&__m128i_op00) = 0x00fffe00fffffe00; ++ *((unsigned long *)&__m128i_result1) = 0x0038f000ff000000; ++ *((unsigned long *)&__m128i_result0) = 0x00fffe00fffffe00; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op00) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_result1) = 0x003f0000003f0000; ++ *((unsigned long *)&__m128i_result0) = 0x003f0000003f0000; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0674c886fcba4e98; ++ *((unsigned long *)&__m128i_op00) = 0xfdce8003090b0906; ++ *((unsigned long *)&__m128i_result1) = 0x003fffc0ffc0003f; ++ *((unsigned long *)&__m128i_result0) = 0xffc0ffc0003f003f; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x04e00060ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x04e00060ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x007fffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x007fffffffffffff; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000017f0a82; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000003f; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x3); ++ *((unsigned long *)&__m128i_op01) = 0x8006000080020000; ++ *((unsigned long *)&__m128i_op00) = 0x8004000080020000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff8fffffff8; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff8fffffff8; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0xffd27db010d20fbf; ++ *((unsigned long *)&__m128i_result1) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff00000000f; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000003ff8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000003ff8; ++ __m128i_out = __lsx_vsat_w (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_d (__m128i_op0, 0x35); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-2.c +new file mode 100644 +index 000000000..31e3919bf +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsat-2.c +@@ -0,0 +1,272 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff1739ffff48aa; ++ *((unsigned long *)&__m128i_op00) = 0xffff2896ffff5b88; ++ *((unsigned long *)&__m128i_result1) = 0x3f3f17393f3f3f3f; ++ *((unsigned long *)&__m128i_result0) = 0x3f3f283f3f3f3f3f; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x000001fc00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010100000000; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffcc000b000b000b; ++ *((unsigned long *)&__m128i_op00) = 0x000b000b010a000b; ++ *((unsigned long *)&__m128i_result1) = 0x7f7f000b000b000b; ++ *((unsigned long *)&__m128i_result0) = 0x000b000b010a000b; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000068; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001f; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffcd63ffffcd63; ++ *((unsigned long *)&__m128i_op00) = 0xffffd765ffffd765; ++ *((unsigned long *)&__m128i_result1) = 0x1f1f1f1f1f1f1f1f; ++ *((unsigned long *)&__m128i_result0) = 0x1f1f1f1f1f1f1f1f; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000120000000d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vsat_bu (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x003f00000000003f; ++ *((unsigned long *)&__m128i_result0) = 0x003f000000000000; ++ __m128i_out = __lsx_vsat_hu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000007f8; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000007f8; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ff; ++ __m128i_out = __lsx_vsat_hu (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_hu (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_hu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000006de1; ++ *((unsigned long *)&__m128i_op00) = 0x5f9ccf33cf600000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000007; ++ *((unsigned long *)&__m128i_result0) = 0x0007000700070000; ++ __m128i_out = __lsx_vsat_hu (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fff7fc01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000f; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000bd3d00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000bd3d00000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007000000050000; ++ *((unsigned long *)&__m128i_op00) = 0x0003000000010000; ++ *((unsigned long *)&__m128i_result1) = 0x00003fff00003fff; ++ *((unsigned long *)&__m128i_result0) = 0x00003fff00003fff; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001a323b5430048c; ++ *((unsigned long *)&__m128i_op00) = 0x008f792cab1cb915; ++ *((unsigned long *)&__m128i_result1) = 0x001a323b00ffffff; ++ *((unsigned long *)&__m128i_result0) = 0x008f792c00ffffff; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_wu (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x20); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636389038903; ++ *((unsigned long *)&__m128i_op00) = 0x6363636389038903; ++ *((unsigned long *)&__m128i_result1) = 0x000000000001ffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000000001ffff; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x22); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x36); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000001fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x34); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result1) = 0x000000001fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa8a74bff9e9e0070; ++ *((unsigned long *)&__m128i_op00) = 0x9e9e72ff9e9ff9ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffffffffffff; ++ __m128i_out = __lsx_vsat_du (__m128i_op0, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vfcmp-instructions.patch
Added
@@ -0,0 +1,5295 @@ +From 8cea23eb3f7e7aee77d0cf87581754c017691b91 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 11:31:16 +0800 +Subject: PATCH 095/124 LoongArch: Add tests for SX vector vfcmp + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_caf.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_ceq.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_cle.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_clt.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_cne.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_cor.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_cun.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_saf.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_seq.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_sle.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_slt.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_sne.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_sor.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfcmp_sun.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vfcmp_caf.c | 244 ++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_ceq.c | 516 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_cle.c | 530 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_clt.c | 476 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_cne.c | 378 +++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_cor.c | 170 ++++++ + .../loongarch/vector/lsx/lsx-vfcmp_cun.c | 253 +++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_saf.c | 214 +++++++ + .../loongarch/vector/lsx/lsx-vfcmp_seq.c | 450 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_sle.c | 407 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_slt.c | 512 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_sne.c | 398 +++++++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_sor.c | 269 +++++++++ + .../loongarch/vector/lsx/lsx-vfcmp_sun.c | 335 +++++++++++ + 14 files changed, 5152 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_caf.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_ceq.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cle.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_clt.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cne.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cun.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_saf.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_seq.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sle.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_slt.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sne.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sor.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sun.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_caf.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_caf.c +new file mode 100644 +index 000000000..b448c2076 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_caf.c +@@ -0,0 +1,244 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x01010101; ++ *((int *)&__m128_op00) = 0x01010101; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7ef400ad; ++ *((int *)&__m128_op02) = 0x21fc7081; ++ *((int *)&__m128_op01) = 0x28bf0351; ++ *((int *)&__m128_op00) = 0xec69b5f2; ++ *((int *)&__m128_op13) = 0xff800000; ++ *((int *)&__m128_op12) = 0xff800000; ++ *((int *)&__m128_op11) = 0xff800000; ++ *((int *)&__m128_op10) = 0x7fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x01000100; ++ *((int *)&__m128_op00) = 0x01000100; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x64e464e4; ++ *((int *)&__m128_op10) = 0x64e464e4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffc0ff80; ++ *((int *)&__m128_op12) = 0xff800000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xc0800000; ++ *((int *)&__m128_op13) = 0x0000001b; ++ *((int *)&__m128_op12) = 0x0000001b; ++ *((int *)&__m128_op11) = 0x0000001b; ++ *((int *)&__m128_op10) = 0x0000001b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000002; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000002; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x34500292; ++ *((int *)&__m128_op10) = 0x0f3017d6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00830029; ++ *((int *)&__m128_op00) = 0x0038ff50; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff7fff80; ++ *((int *)&__m128_op02) = 0xff800001; ++ *((int *)&__m128_op01) = 0xe593d844; ++ *((int *)&__m128_op00) = 0xe593c8c4; ++ *((int *)&__m128_op13) = 0xff800000; ++ *((int *)&__m128_op12) = 0xff800000; ++ *((int *)&__m128_op11) = 0xe593c8c4; ++ *((int *)&__m128_op10) = 0xe593c8c4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x8a8a8a8a; ++ *((int *)&__m128_op12) = 0x8a8a8a8a; ++ *((int *)&__m128_op11) = 0x8a8a8a8a; ++ *((int *)&__m128_op10) = 0x8a8a8a8a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x66b34f643c9c626a; ++ *((unsigned long *)&__m128d_op00) = 0x38d60e366e547876; ++ *((unsigned long *)&__m128d_op11) = 0x66b34f643c9c626a; ++ *((unsigned long *)&__m128d_op10) = 0x38d60e366e547876; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128d_op00) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128d_op11) = 0x000700000004fdff; ++ *((unsigned long *)&__m128d_op10) = 0x000300000000fdff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xf2f444429d96dbe1; ++ *((unsigned long *)&__m128d_op00) = 0xddd76c75f2f44442; ++ *((unsigned long *)&__m128d_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128d_op10) = 0xc1f03e1042208410; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffbfff7fffc000; ++ *((unsigned long *)&__m128d_op00) = 0xffff43dfffff81fb; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_caf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_ceq.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_ceq.c +new file mode 100644 +index 000000000..98941b47d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_ceq.c +@@ -0,0 +1,516 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00007f00; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x01000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x08fdc221; ++ *((int *)&__m128_op02) = 0xbfdb1927; ++ *((int *)&__m128_op01) = 0x4303c67e; ++ *((int *)&__m128_op00) = 0x9b7fb213; ++ *((int *)&__m128_op13) = 0x0000800c; ++ *((int *)&__m128_op12) = 0x0004300c; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000800; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00007fff; ++ *((int *)&__m128_op02) = 0x00007fff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x2bfd9461; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x2bfd9461; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x01000000; ++ *((int *)&__m128_op00) = 0x01000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xcd636363; ++ *((int *)&__m128_op12) = 0xcd636363; ++ *((int *)&__m128_op11) = 0xcd636363; ++ *((int *)&__m128_op10) = 0xcd636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x007fffff; ++ *((int *)&__m128_op01) = 0x007fffff; ++ *((int *)&__m128_op00) = 0xff800000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x0000cecd; ++ *((int *)&__m128_op12) = 0x00004657; ++ *((int *)&__m128_op11) = 0x0000c900; ++ *((int *)&__m128_op10) = 0x00011197; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xf51df8db; ++ *((int *)&__m128_op02) = 0xd6050189; ++ *((int *)&__m128_op01) = 0x0983e2db; ++ *((int *)&__m128_op00) = 0xf235ed87; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0x3ea5016b; ++ *((int *)&__m128_op11) = 0xfffefffe; ++ *((int *)&__m128_op10) = 0x3f6fb04d; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xffa8ff9f; ++ *((int *)&__m128_op11) = 0x0000ffff; ++ *((int *)&__m128_op10) = 0xffabff99; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000ff00; ++ *((int *)&__m128_op13) = 0x40404040; ++ *((int *)&__m128_op12) = 0x40404040; ++ *((int *)&__m128_op11) = 0x40404040; ++ *((int *)&__m128_op10) = 0x40404040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x3bcc5098; ++ *((int *)&__m128_op12) = 0x703fa5f0; ++ *((int *)&__m128_op11) = 0xab7b3134; ++ *((int *)&__m128_op10) = 0x9703f605; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x000000ff; ++ *((int *)&__m128_op00) = 0xfe01fd02; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x0001fe01; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x000000ff; ++ *((int *)&__m128_op00) = 0xfe01fd02; ++ *((int *)&__m128_op13) = 0x00000001; ++ *((int *)&__m128_op12) = 0x00000100; ++ *((int *)&__m128_op11) = 0x00000001; ++ *((int *)&__m128_op10) = 0x00000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00800000; ++ *((int *)&__m128_op00) = 0x00800000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00800000; ++ *((int *)&__m128_op10) = 0x00800000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xc2409edab019323f; ++ *((unsigned long *)&__m128d_op00) = 0x460f3b393ef4be3a; ++ *((unsigned long *)&__m128d_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m128d_op10) = 0x0100000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000ff00000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000ff00000000; ++ *((unsigned long *)&__m128d_op11) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128d_op10) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128d_op00) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128d_op10) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128d_op00) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128d_op11) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128d_op10) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_ceq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m128d_op10) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_ceq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0100000001000100; ++ *((unsigned long *)&__m128d_op00) = 0x0100010000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128d_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128d_op10) = 0x0000c000ffffc000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128d_op10) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffe000ffdf; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000010100000101; ++ *((unsigned long *)&__m128d_op00) = 0x0000010100000101; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000000000000b; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xd78cfd70b5f65d77; ++ *((unsigned long *)&__m128d_op10) = 0x5779108fdedda7e5; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000ff0000ffff; ++ *((unsigned long *)&__m128d_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cle.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cle.c +new file mode 100644 +index 000000000..409bce0ec +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cle.c +@@ -0,0 +1,530 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00001802; ++ *((int *)&__m128_op00) = 0x041b0013; ++ *((int *)&__m128_op13) = 0xff800000; ++ *((int *)&__m128_op12) = 0xff800000; ++ *((int *)&__m128_op11) = 0xff800000; ++ *((int *)&__m128_op10) = 0xc3080000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x17fda829; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000404; ++ *((int *)&__m128_op12) = 0x00000383; ++ *((int *)&__m128_op11) = 0xffffe000; ++ *((int *)&__m128_op10) = 0xffff1fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x000000fe; ++ *((int *)&__m128_op02) = 0x808000ff; ++ *((int *)&__m128_op01) = 0x000000fe; ++ *((int *)&__m128_op00) = 0x808000fe; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000020; ++ *((int *)&__m128_op02) = 0x00000020; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x0000ffc1; ++ *((int *)&__m128_op10) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000004; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xe0000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x01010001; ++ *((int *)&__m128_op12) = 0x00010001; ++ *((int *)&__m128_op11) = 0x01010301; ++ *((int *)&__m128_op10) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffff00; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000001; ++ *((int *)&__m128_op12) = 0x00000001; ++ *((int *)&__m128_op11) = 0x00000001; ++ *((int *)&__m128_op10) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000001; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00010001; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00060fbf; ++ *((int *)&__m128_op12) = 0x02040fbf; ++ *((int *)&__m128_op11) = 0x00020fbf; ++ *((int *)&__m128_op10) = 0x02000fbf; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0a752a55; ++ *((int *)&__m128_op01) = 0x0a753500; ++ *((int *)&__m128_op00) = 0x950fa306; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x380fdfdf; ++ *((int *)&__m128_op10) = 0xc0000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000007fff800000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000080007f80800; ++ *((unsigned long *)&__m128d_op00) = 0x0000000001000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000080800000808; ++ *((unsigned long *)&__m128d_op00) = 0x0000080800000808; ++ *((unsigned long *)&__m128d_op11) = 0xffffffff80800001; ++ *((unsigned long *)&__m128d_op10) = 0xffffffff80800001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x5f675e96a8d359f5; ++ *((unsigned long *)&__m128d_op00) = 0x46387f95d9a68001; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x131211101211100f; ++ *((unsigned long *)&__m128d_op00) = 0x11100f0e100f0e0d; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000000002a000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffff7f8c; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x98147a504d145000; ++ *((unsigned long *)&__m128d_op10) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128d_op11) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128d_op10) = 0xfcfcfcfcfcfc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xfffffffff359f358; ++ *((unsigned long *)&__m128d_op10) = 0xfffffffff359f358; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000003ff8; ++ *((unsigned long *)&__m128d_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128d_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000001; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x4f804f81; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x4f804f80; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7fff0007; ++ *((int *)&__m128_op02) = 0xe215b122; ++ *((int *)&__m128_op01) = 0x7ffeffff; ++ *((int *)&__m128_op00) = 0x7bfff828; ++ *((int *)&__m128_op13) = 0x80010009; ++ *((int *)&__m128_op12) = 0x816ac5de; ++ *((int *)&__m128_op11) = 0x80010001; ++ *((int *)&__m128_op10) = 0x84000bd8; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xfefa0000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x9c9c9c9c; ++ *((int *)&__m128_op12) = 0x9c9c9c9c; ++ *((int *)&__m128_op11) = 0x9c9c9c9c; ++ *((int *)&__m128_op10) = 0x9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0c0b0a09; ++ *((int *)&__m128_op02) = 0x0b0a0908; ++ *((int *)&__m128_op01) = 0x0a090807; ++ *((int *)&__m128_op00) = 0x09080706; ++ *((int *)&__m128_op13) = 0x0c0b0a09; ++ *((int *)&__m128_op12) = 0x0b0a0908; ++ *((int *)&__m128_op11) = 0x0a090807; ++ *((int *)&__m128_op10) = 0x09080706; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000020; ++ *((int *)&__m128_op12) = 0x00000020; ++ *((int *)&__m128_op11) = 0x0000001f; ++ *((int *)&__m128_op10) = 0x0000001f; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7ff80000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x7ff80000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff80ff0010ff06; ++ *((unsigned long *)&__m128d_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128d_op11) = 0xedfaedfaedfaedfa; ++ *((unsigned long *)&__m128d_op10) = 0xedfaedfaedfaedfa; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_clt.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_clt.c +new file mode 100644 +index 000000000..39c9cf7a7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_clt.c +@@ -0,0 +1,476 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x56411278; ++ *((int *)&__m128_op02) = 0x43c0d41e; ++ *((int *)&__m128_op01) = 0x0124d8f6; ++ *((int *)&__m128_op00) = 0xa494006b; ++ *((int *)&__m128_op13) = 0x7f800000; ++ *((int *)&__m128_op12) = 0xff800000; ++ *((int *)&__m128_op11) = 0xff800000; ++ *((int *)&__m128_op10) = 0xff800000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x84939413; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000002; ++ *((int *)&__m128_op00) = 0xbefcb21e; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xfffefff6; ++ *((int *)&__m128_op00) = 0xfff80002; ++ *((int *)&__m128_op13) = 0x000000c5; ++ *((int *)&__m128_op12) = 0xac01015b; ++ *((int *)&__m128_op11) = 0xaaacac88; ++ *((int *)&__m128_op10) = 0xa3a9a96a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff84fff4; ++ *((int *)&__m128_op02) = 0xff84fff4; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffff0; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x11000f20; ++ *((int *)&__m128_op02) = 0x10000e20; ++ *((int *)&__m128_op01) = 0x0f000d20; ++ *((int *)&__m128_op00) = 0x0e000c20; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000c00; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00bd003d; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000005; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000005; ++ *((int *)&__m128_op13) = 0xfffefffe; ++ *((int *)&__m128_op12) = 0xfffefffe; ++ *((int *)&__m128_op11) = 0xfffefffe; ++ *((int *)&__m128_op10) = 0xfffefffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xff800001; ++ *((int *)&__m128_op00) = 0x0f800000; ++ *((int *)&__m128_op13) = 0x00000009; ++ *((int *)&__m128_op12) = 0x00000009; ++ *((int *)&__m128_op11) = 0xff80000a; ++ *((int *)&__m128_op10) = 0x0f800009; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0000ffff; ++ *((int *)&__m128_op01) = 0x3b5eae24; ++ *((int *)&__m128_op00) = 0xab7e3848; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00003f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x63636363; ++ *((int *)&__m128_op02) = 0x3f3e47c1; ++ *((int *)&__m128_op01) = 0x41f8e080; ++ *((int *)&__m128_op00) = 0xf1ef4eaa; ++ *((int *)&__m128_op13) = 0x0000cecd; ++ *((int *)&__m128_op12) = 0x00004657; ++ *((int *)&__m128_op11) = 0x0000c900; ++ *((int *)&__m128_op10) = 0x00011197; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_clt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x454c2996; ++ *((int *)&__m128_op02) = 0x0ffe354e; ++ *((int *)&__m128_op01) = 0x9e063f80; ++ *((int *)&__m128_op00) = 0x2742ba3e; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x42652524; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00070000; ++ *((int *)&__m128_op02) = 0x00050000; ++ *((int *)&__m128_op01) = 0x00030000; ++ *((int *)&__m128_op00) = 0x00010000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xff81007c; ++ *((int *)&__m128_op11) = 0xffb7005f; ++ *((int *)&__m128_op10) = 0x0070007c; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0000006f; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfbffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x7bffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xfbffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x7bffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0002a000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x0002a000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xfc606ec5; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x14155445; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x01030103; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00060fbf; ++ *((int *)&__m128_op02) = 0x02040fbf; ++ *((int *)&__m128_op01) = 0x00020fbf; ++ *((int *)&__m128_op00) = 0x02000fbf; ++ *((int *)&__m128_op13) = 0x63636363; ++ *((int *)&__m128_op12) = 0x63636363; ++ *((int *)&__m128_op11) = 0xffd27db0; ++ *((int *)&__m128_op10) = 0x10d20fbf; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7f800000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000008; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000010000003f; ++ *((unsigned long *)&__m128d_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128d_op10) = 0x000000010000003f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m128d_op11) = 0x0000000036de0000; ++ *((unsigned long *)&__m128d_op10) = 0x000000003be14000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x1111113111111141; ++ *((unsigned long *)&__m128d_op00) = 0x1111113111111121; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0032000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000080000000; ++ *((unsigned long *)&__m128d_op11) = 0xe93d0bd19ff07013; ++ *((unsigned long *)&__m128d_op10) = 0x65017c2ac9ca9fd0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x007f007f007f007e; ++ *((unsigned long *)&__m128d_op10) = 0x007f007f007effc6; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000015800000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128d_op00) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128d_op11) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128d_op10) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7f8100017f810001; ++ *((unsigned long *)&__m128d_op00) = 0x7f8100017f810001; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_clt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x004200a000000000; ++ *((unsigned long *)&__m128d_op00) = 0x004200a000200001; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x7fff00007fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128d_op10) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000001e; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000455555555; ++ *((unsigned long *)&__m128d_op11) = 0x0000000001580000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m128d_op00) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cne.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cne.c +new file mode 100644 +index 000000000..c3da43bb4 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cne.c +@@ -0,0 +1,378 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x7ff80000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x0bd80bd8; ++ *((int *)&__m128_op12) = 0x0bdfffff; ++ *((int *)&__m128_op11) = 0x0bd80bd8; ++ *((int *)&__m128_op10) = 0x0bd80000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00ff0077; ++ *((int *)&__m128_op02) = 0x00070077; ++ *((int *)&__m128_op01) = 0x00e600ef; ++ *((int *)&__m128_op00) = 0x00ee01de; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00007fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00100010; ++ *((int *)&__m128_op02) = 0x00100010; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x000000ff; ++ *((int *)&__m128_op10) = 0xfe01fd02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xbf800000; ++ *((int *)&__m128_op02) = 0x0000ffff; ++ *((int *)&__m128_op01) = 0xcf000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x003f0000; ++ *((int *)&__m128_op12) = 0x0000003f; ++ *((int *)&__m128_op11) = 0x003f0000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x01ff01ff; ++ *((int *)&__m128_op02) = 0x01ff01ff; ++ *((int *)&__m128_op01) = 0x01ff01ff; ++ *((int *)&__m128_op00) = 0x01ff01ff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x20202020; ++ *((int *)&__m128_op02) = 0x20202020; ++ *((int *)&__m128_op01) = 0x20202020; ++ *((int *)&__m128_op00) = 0x20207fff; ++ *((int *)&__m128_op13) = 0x32d3f35e; ++ *((int *)&__m128_op12) = 0xcd509d13; ++ *((int *)&__m128_op11) = 0x3e081b3c; ++ *((int *)&__m128_op10) = 0x93f6b356; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffff0000; ++ *((int *)&__m128_op02) = 0xffff0000; ++ *((int *)&__m128_op01) = 0x40408010; ++ *((int *)&__m128_op00) = 0x80200110; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x80000000; ++ *((int *)&__m128_op02) = 0x80000008; ++ *((int *)&__m128_op01) = 0xa2f54a1e; ++ *((int *)&__m128_op00) = 0xa2f54a1e; ++ *((int *)&__m128_op13) = 0x80000000; ++ *((int *)&__m128_op12) = 0x80000008; ++ *((int *)&__m128_op11) = 0xa2f54a1e; ++ *((int *)&__m128_op10) = 0xa2f54a1e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000000000fc00; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000fc00; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0001000100000004; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000020302030; ++ *((unsigned long *)&__m128d_op00) = 0x0000000020302030; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000100010; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000100010; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x5d7f5d007f6a007f; ++ *((unsigned long *)&__m128d_op10) = 0x7fff7fff7fff7f00; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x7ff000ff6220c0c1; ++ *((unsigned long *)&__m128d_op10) = 0xffe8081000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128d_op10) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x1c083b1f3b1f3b1f; ++ *((unsigned long *)&__m128d_op00) = 0xf244b948a323ab42; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128d_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000100fe000070a1; ++ *((unsigned long *)&__m128d_op00) = 0x00000115ffffffa1; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffffffff8f8da00; ++ *((unsigned long *)&__m128d_op00) = 0xffffffff01018888; ++ *((unsigned long *)&__m128d_op11) = 0x000000003ea5016c; ++ *((unsigned long *)&__m128d_op10) = 0xfffefefd3f7027c5; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000ffce; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x400000003fffffff; ++ *((unsigned long *)&__m128d_op00) = 0x4000000040000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128d_op00) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x00007fff7fff8000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cor.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cor.c +new file mode 100644 +index 000000000..5228dbede +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cor.c +@@ -0,0 +1,170 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_cor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfffffeff; ++ *((int *)&__m128_op02) = 0xfffffeff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffcff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00800000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xf4b6f3f5; ++ *((int *)&__m128_op00) = 0x2f4ef4a8; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x08080808; ++ *((int *)&__m128_op12) = 0x08080808; ++ *((int *)&__m128_op11) = 0x08080808; ++ *((int *)&__m128_op10) = 0x08080808; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000ffce; ++ *((int *)&__m128_op13) = 0xffff0001; ++ *((int *)&__m128_op12) = 0x1cf0c569; ++ *((int *)&__m128_op11) = 0xc0000002; ++ *((int *)&__m128_op10) = 0xb0995850; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x0a752a55; ++ *((int *)&__m128_op01) = 0x0a753500; ++ *((int *)&__m128_op00) = 0x950fa306; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x0a752a55; ++ *((int *)&__m128_op11) = 0x0a753500; ++ *((int *)&__m128_op10) = 0x950fa306; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128d_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128d_op11) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128d_op10) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000ffffffdfffdf; ++ *((unsigned long *)&__m128d_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000ffffffdfffdf; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128d_op00) = 0xa352bfac9269e0aa; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cun.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cun.c +new file mode 100644 +index 000000000..a2beff53f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_cun.c +@@ -0,0 +1,253 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x0000ffff; ++ *((int *)&__m128_op02) = 0x0000ffff; ++ *((int *)&__m128_op01) = 0x0000ffff; ++ *((int *)&__m128_op00) = 0x0000fffe; ++ *((int *)&__m128_op13) = 0x0000ffff; ++ *((int *)&__m128_op12) = 0x0000ffff; ++ *((int *)&__m128_op11) = 0x0000ffff; ++ *((int *)&__m128_op10) = 0x0000fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00200010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7f800000; ++ *((int *)&__m128_op02) = 0x7f800000; ++ *((int *)&__m128_op01) = 0x7f800000; ++ *((int *)&__m128_op00) = 0x7f800000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x0000fffe; ++ *((int *)&__m128_op00) = 0x0000ffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffff0008; ++ *((int *)&__m128_op13) = 0xffc2ffe0; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x0000ffc1; ++ *((int *)&__m128_op10) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000008; ++ *((int *)&__m128_op01) = 0x00200020; ++ *((int *)&__m128_op00) = 0x00200020; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfffefffe; ++ *((int *)&__m128_op02) = 0xfffefffe; ++ *((int *)&__m128_op01) = 0xfffefffe; ++ *((int *)&__m128_op00) = 0xfffefffe; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xf001f001; ++ *((int *)&__m128_op10) = 0x0101f002; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xfeffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xfeffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000fff; ++ *((int *)&__m128_op12) = 0xffffe000; ++ *((int *)&__m128_op11) = 0x00001020; ++ *((int *)&__m128_op10) = 0x20204000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfefd7f7f7f7f7f7e; ++ *((unsigned long *)&__m128d_op00) = 0xdffdbffeba6f5543; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff3d06ffff4506; ++ *((unsigned long *)&__m128d_op00) = 0x7ffffffe7ffff800; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000003bfb4000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000100010100; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff00011cf0c569; ++ *((unsigned long *)&__m128d_op00) = 0xc0000002b0995850; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128d_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128d_op00) = 0x0000000024170000; ++ *((unsigned long *)&__m128d_op11) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128d_op10) = 0x0000000044470000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_cun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_saf.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_saf.c +new file mode 100644 +index 000000000..bfa4914be +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_saf.c +@@ -0,0 +1,214 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0x80000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00a300a3; ++ *((int *)&__m128_op12) = 0x00a300a3; ++ *((int *)&__m128_op11) = 0x00a300a3; ++ *((int *)&__m128_op10) = 0x00a300a3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xb8ec43be; ++ *((int *)&__m128_op12) = 0xfe38e64b; ++ *((int *)&__m128_op11) = 0x6477d042; ++ *((int *)&__m128_op10) = 0x343cce24; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000010; ++ *((int *)&__m128_op02) = 0x00100010; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00020000; ++ *((int *)&__m128_op00) = 0xffff0001; ++ *((int *)&__m128_op13) = 0x63636363; ++ *((int *)&__m128_op12) = 0x63636363; ++ *((int *)&__m128_op11) = 0x63636363; ++ *((int *)&__m128_op10) = 0x63636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x03080401; ++ *((int *)&__m128_op02) = 0x0d090107; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0a0a0a000a0a0a00; ++ *((unsigned long *)&__m128d_op10) = 0x0a0a0a0009090900; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ffffff01; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x000000007ff000ff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x67157b5100005000; ++ *((unsigned long *)&__m128d_op10) = 0x387c7e0a133f2000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xf359f359f359f359; ++ *((unsigned long *)&__m128d_op00) = 0xf359f359f359f359; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0177fff0fffffff0; ++ *((unsigned long *)&__m128d_op10) = 0x00000000011ff8bc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_saf_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_seq.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_seq.c +new file mode 100644 +index 000000000..bc573936d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_seq.c +@@ -0,0 +1,450 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xf2f2e5e5; ++ *((int *)&__m128_op02) = 0xe5e5e5e5; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xe5e5e5e5; ++ *((int *)&__m128_op12) = 0xe5e5e5e5; ++ *((int *)&__m128_op11) = 0xe5e5e5e5; ++ *((int *)&__m128_op10) = 0xe4e4e46d; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00800000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x1f400000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x14ccc632; ++ *((int *)&__m128_op02) = 0x0076a4d2; ++ *((int *)&__m128_op01) = 0x685670d2; ++ *((int *)&__m128_op00) = 0x7e00682a; ++ *((int *)&__m128_op13) = 0x14ccc632; ++ *((int *)&__m128_op12) = 0x0076a4d2; ++ *((int *)&__m128_op11) = 0x685670d2; ++ *((int *)&__m128_op10) = 0x7e00682a; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00010001; ++ *((int *)&__m128_op02) = 0x00010001; ++ *((int *)&__m128_op01) = 0x00010001; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xc6c6c6c6; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xc6c6c6c6; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xc6c6c6c6; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0xc6c6c6c6; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000006; ++ *((int *)&__m128_op12) = 0x00007fff; ++ *((int *)&__m128_op11) = 0x00000008; ++ *((int *)&__m128_op10) = 0xffffa209; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_seq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00fc0000; ++ *((int *)&__m128_op13) = 0xfe07e5fe; ++ *((int *)&__m128_op12) = 0xfefdddfe; ++ *((int *)&__m128_op11) = 0x00020100; ++ *((int *)&__m128_op10) = 0xfedd0c00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffff0000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000fffd; ++ *((int *)&__m128_op13) = 0x7fffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00008000; ++ *((int *)&__m128_op12) = 0x3f80ffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x370bdfec; ++ *((int *)&__m128_op02) = 0xffecffec; ++ *((int *)&__m128_op01) = 0x370bdfec; ++ *((int *)&__m128_op00) = 0xa2eb9931; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000040; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000040; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xc2fc0000; ++ *((int *)&__m128_op12) = 0xc3040000; ++ *((int *)&__m128_op11) = 0xc2fc0000; ++ *((int *)&__m128_op10) = 0xc3040000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00fe00fe; ++ *((int *)&__m128_op02) = 0x000200fe; ++ *((int *)&__m128_op01) = 0x00fe00fe; ++ *((int *)&__m128_op00) = 0x000200fe; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000004; ++ *((int *)&__m128_op10) = 0x55555555; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000158; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffffffa8; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xf3e6586b; ++ *((int *)&__m128_op02) = 0x60d7b152; ++ *((int *)&__m128_op01) = 0xf7077b93; ++ *((int *)&__m128_op00) = 0x4ac0e000; ++ *((int *)&__m128_op13) = 0x1498507a; ++ *((int *)&__m128_op12) = 0x144d0050; ++ *((int *)&__m128_op11) = 0x7b370981; ++ *((int *)&__m128_op10) = 0xc01200e0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffc2007a; ++ *((int *)&__m128_op02) = 0xff230027; ++ *((int *)&__m128_op01) = 0x0080005e; ++ *((int *)&__m128_op00) = 0xff600001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000100010001fffd; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_seq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x000000004fc04f81; ++ *((unsigned long *)&__m128d_op10) = 0x000000004fc04f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_seq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_seq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x13f9c5b60028a415; ++ *((unsigned long *)&__m128d_op10) = 0x545cab1d81a83bea; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_seq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_seq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfefd7f7f7f7f7f7e; ++ *((unsigned long *)&__m128d_op00) = 0xdffdbffeba6f5543; ++ *((unsigned long *)&__m128d_op11) = 0xfefd7f7f7f7f7f7e; ++ *((unsigned long *)&__m128d_op10) = 0xdffdbffeba6f5543; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xfffffff700000009; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xfffffff700000009; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128d_op00) = 0x4fa432d67fc00000; ++ *((unsigned long *)&__m128d_op11) = 0x0141010101410101; ++ *((unsigned long *)&__m128d_op10) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffcffff00000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000fffd000a0000; ++ *((unsigned long *)&__m128d_op11) = 0xf0fd800080000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000a00028004000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00820082ff81ff81; ++ *((unsigned long *)&__m128d_op00) = 0xff81ff81ff81ff81; ++ *((unsigned long *)&__m128d_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128d_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000001000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000120002000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0007000100040102; ++ *((unsigned long *)&__m128d_op00) = 0x0003000100010101; ++ *((unsigned long *)&__m128d_op11) = 0x0007000100040102; ++ *((unsigned long *)&__m128d_op10) = 0x0003000100010101; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sueq_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sle.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sle.c +new file mode 100644 +index 000000000..87cb8da7c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sle.c +@@ -0,0 +1,407 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffdfff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffdfff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffe000; ++ *((int *)&__m128_op10) = 0x01ffe200; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00010002; ++ *((int *)&__m128_op02) = 0x0000fe7d; ++ *((int *)&__m128_op01) = 0x00010002; ++ *((int *)&__m128_op00) = 0x0000fe02; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x0000007b; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x1223dabf; ++ *((int *)&__m128_op02) = 0x4c3b3549; ++ *((int *)&__m128_op01) = 0x8e8f8626; ++ *((int *)&__m128_op00) = 0xf15be124; ++ *((int *)&__m128_op13) = 0xfffffacd; ++ *((int *)&__m128_op12) = 0xb6dbecac; ++ *((int *)&__m128_op11) = 0x1f5533a6; ++ *((int *)&__m128_op10) = 0x94f902c0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xfbffffff; ++ *((int *)&__m128_op00) = 0x27001517; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x0000ffff; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffff53d9; ++ *((int *)&__m128_op01) = 0xffff0001; ++ *((int *)&__m128_op00) = 0xffff9515; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00010001; ++ *((int *)&__m128_op12) = 0x00010001; ++ *((int *)&__m128_op11) = 0x00010001; ++ *((int *)&__m128_op10) = 0x00010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000080; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00df020f; ++ *((int *)&__m128_op00) = 0x0078007f; ++ *((int *)&__m128_op13) = 0x0037ffd4; ++ *((int *)&__m128_op12) = 0x0083ffe5; ++ *((int *)&__m128_op11) = 0x001e0052; ++ *((int *)&__m128_op10) = 0x001ffff9; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00ff00ff; ++ *((int *)&__m128_op00) = 0x00ff00ff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x05452505; ++ *((int *)&__m128_op01) = 0x00000004; ++ *((int *)&__m128_op00) = 0x442403e4; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000101; ++ *((int *)&__m128_op02) = 0x00000101; ++ *((int *)&__m128_op01) = 0x00000101; ++ *((int *)&__m128_op00) = 0x00000101; ++ *((int *)&__m128_op13) = 0x00000002; ++ *((int *)&__m128_op12) = 0x00000002; ++ *((int *)&__m128_op11) = 0x00000002; ++ *((int *)&__m128_op10) = 0x00000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00010000; ++ *((int *)&__m128_op02) = 0x00010000; ++ *((int *)&__m128_op01) = 0x0000cd63; ++ *((int *)&__m128_op00) = 0x0000cd63; ++ *((int *)&__m128_op13) = 0xffffcd63; ++ *((int *)&__m128_op12) = 0xffffcd63; ++ *((int *)&__m128_op11) = 0xffffd765; ++ *((int *)&__m128_op10) = 0xffffd765; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffff00ff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffff0000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0x0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffff0c8000c212; ++ *((unsigned long *)&__m128d_op00) = 0xfefffeff7f002d06; ++ *((unsigned long *)&__m128d_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128d_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128d_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00f0008100800080; ++ *((unsigned long *)&__m128d_op00) = 0x00f000807000009e; ++ *((unsigned long *)&__m128d_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128d_op10) = 0xfffe00029f9f6061; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffc0800000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000c0010000a186; ++ *((unsigned long *)&__m128d_op10) = 0x00067fff0002a207; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sle_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffff80000001; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x3fbf3fbf00007fff; ++ *((unsigned long *)&__m128d_op11) = 0x000000003fbf3fbf; ++ *((unsigned long *)&__m128d_op10) = 0x7fff7fff7fff7ff8; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x00000000013ec13e; ++ *((unsigned long *)&__m128d_op10) = 0xc03fc03fc0ff00ff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffff00018d8b; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x67eb85af0000b000; ++ *((unsigned long *)&__m128d_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128d_op00) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sule_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_slt.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_slt.c +new file mode 100644 +index 000000000..3845e8ec3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_slt.c +@@ -0,0 +1,512 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x0000ffff; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x0000ffff; ++ *((int *)&__m128_op10) = 0x0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7f800000; ++ *((int *)&__m128_op02) = 0x7f800000; ++ *((int *)&__m128_op01) = 0x7f800000; ++ *((int *)&__m128_op00) = 0x7f800000; ++ *((int *)&__m128_op13) = 0x7f800000; ++ *((int *)&__m128_op12) = 0x7f800000; ++ *((int *)&__m128_op11) = 0x7f800000; ++ *((int *)&__m128_op10) = 0x7f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000001; ++ *((int *)&__m128_op02) = 0x00007f01; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffff02; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x05452505; ++ *((int *)&__m128_op11) = 0x00000004; ++ *((int *)&__m128_op10) = 0x442403e4; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x5f675e96; ++ *((int *)&__m128_op02) = 0xe29a5a60; ++ *((int *)&__m128_op01) = 0x7fff7fff; ++ *((int *)&__m128_op00) = 0x7fff7fff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x5e695e95; ++ *((int *)&__m128_op10) = 0xe1cb5a01; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00800080; ++ *((int *)&__m128_op02) = 0x00800080; ++ *((int *)&__m128_op01) = 0x0080006b; ++ *((int *)&__m128_op00) = 0x0000000b; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x80808080; ++ *((int *)&__m128_op10) = 0x806b000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7f800000; ++ *((int *)&__m128_op02) = 0x7f800000; ++ *((int *)&__m128_op01) = 0x7f800000; ++ *((int *)&__m128_op00) = 0x7f800000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff800000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xff800000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xfffefffe; ++ *((int *)&__m128_op00) = 0xfffffffc; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xfffefffe; ++ *((int *)&__m128_op10) = 0xfffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffc2ffe7; ++ *((int *)&__m128_op02) = 0x00000007; ++ *((int *)&__m128_op01) = 0x0000ffc1; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0xfffff1a0; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x153e3e49; ++ *((int *)&__m128_op02) = 0x307d0771; ++ *((int *)&__m128_op01) = 0x0d8e3670; ++ *((int *)&__m128_op00) = 0x6ac02b9b; ++ *((int *)&__m128_op13) = 0x55aa55c3; ++ *((int *)&__m128_op12) = 0xd5aa55c4; ++ *((int *)&__m128_op11) = 0xaa55556f; ++ *((int *)&__m128_op10) = 0xd5aaaac1; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0x0015172b; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xfffffffe; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xfffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffff0000; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00010001; ++ *((int *)&__m128_op02) = 0x00010001; ++ *((int *)&__m128_op01) = 0x00010001; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x86dd8341; ++ *((int *)&__m128_op12) = 0xb164f12b; ++ *((int *)&__m128_op11) = 0x9611c398; ++ *((int *)&__m128_op10) = 0x5b3159f5; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_sult_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000001f; ++ *((unsigned long *)&__m128d_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m128d_op10) = 0x0000000300000003; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xe93d0bd19ff07013; ++ *((unsigned long *)&__m128d_op00) = 0x65017c2ac9ca9fd0; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00d3012acc56f9bb; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000001021; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x14ccc6320176a4d2; ++ *((unsigned long *)&__m128d_op00) = 0x685670d37e80682a; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x003fffff00000000; ++ *((unsigned long *)&__m128d_op10) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000001000000010; ++ *((unsigned long *)&__m128d_op10) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0080000000800000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x345002920f3017d6; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_slt_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffff8607db959f; ++ *((unsigned long *)&__m128d_op00) = 0xff0cff78ff96ff14; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x7ef8000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x14ccc6320176a4d2; ++ *((unsigned long *)&__m128d_op00) = 0x685670d37e80682a; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m128d_op10) = 0xffffffee00000004; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x80808080806b000b; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sult_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sne.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sne.c +new file mode 100644 +index 000000000..964eff79f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sne.c +@@ -0,0 +1,398 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00003fee; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000004; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000002; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x03574e3a; ++ *((int *)&__m128_op12) = 0x03574e3a; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00010400; ++ *((int *)&__m128_op13) = 0x10f917d7; ++ *((int *)&__m128_op12) = 0x2d3d01e4; ++ *((int *)&__m128_op11) = 0x203e16d1; ++ *((int *)&__m128_op10) = 0x16de012b; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0000101f; ++ *((int *)&__m128_op02) = 0xffff8b68; ++ *((int *)&__m128_op01) = 0x00000b6f; ++ *((int *)&__m128_op00) = 0xffff8095; ++ *((int *)&__m128_op13) = 0x10f917d7; ++ *((int *)&__m128_op12) = 0x2d3d01e4; ++ *((int *)&__m128_op11) = 0x203e16d1; ++ *((int *)&__m128_op10) = 0x16de012b; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x11000f20; ++ *((int *)&__m128_op02) = 0x10000e20; ++ *((int *)&__m128_op01) = 0x0f000d20; ++ *((int *)&__m128_op00) = 0x0e000c20; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00050005; ++ *((int *)&__m128_op02) = 0x00050005; ++ *((int *)&__m128_op01) = 0x00050005; ++ *((int *)&__m128_op00) = 0x00050005; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x15d926c7; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000e41b; ++ *((int *)&__m128_op13) = 0xfffffacd; ++ *((int *)&__m128_op12) = 0xb6dbecac; ++ *((int *)&__m128_op11) = 0x1f5533a6; ++ *((int *)&__m128_op10) = 0x94f902c0; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x04040504; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x04040504; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0001000c; ++ *((int *)&__m128_op02) = 0xfffffff2; ++ *((int *)&__m128_op01) = 0x0001000d; ++ *((int *)&__m128_op00) = 0xfffffff1; ++ *((int *)&__m128_op13) = 0xffff8a17; ++ *((int *)&__m128_op12) = 0xffffc758; ++ *((int *)&__m128_op11) = 0xffff69bb; ++ *((int *)&__m128_op10) = 0xffffad3b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_sune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xff800000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xff800000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffff1739; ++ *((int *)&__m128_op12) = 0xffff48aa; ++ *((int *)&__m128_op11) = 0xffff2896; ++ *((int *)&__m128_op10) = 0xffff5b88; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000003; ++ *((int *)&__m128_op00) = 0x0000003f; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000003; ++ *((int *)&__m128_op10) = 0x0000003f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x084d12ce; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x24170000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_sune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7474f6fd7474fefe; ++ *((unsigned long *)&__m128d_op00) = 0xf474f6fef474f6fe; ++ *((unsigned long *)&__m128d_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128d_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128d_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x1817161517161514; ++ *((unsigned long *)&__m128d_op10) = 0x1615141315141312; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0101fe870101fe87; ++ *((unsigned long *)&__m128d_op00) = 0x0101fe8700000000; ++ *((unsigned long *)&__m128d_op11) = 0x62cbf96e4acfaf40; ++ *((unsigned long *)&__m128d_op10) = 0xf0bc9a5278285a4a; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000007fffa9ed; ++ *((unsigned long *)&__m128d_op00) = 0x7f8000017fffca8b; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ffff7603; ++ *((unsigned long *)&__m128d_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sne_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x1111113111111141; ++ *((unsigned long *)&__m128d_op10) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00ff000100ff00fe; ++ *((unsigned long *)&__m128d_op00) = 0x00ff003000ff00a0; ++ *((unsigned long *)&__m128d_op11) = 0x000000005e695e95; ++ *((unsigned long *)&__m128d_op10) = 0x5e695e96c396b402; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x000300037ff000ff; ++ *((unsigned long *)&__m128d_op10) = 0x0003000300a10003; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0001000101010001; ++ *((unsigned long *)&__m128d_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000008000000080; ++ *((unsigned long *)&__m128d_op10) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000003ff8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x01533b5e7489ae24; ++ *((unsigned long *)&__m128d_op00) = 0xffffab7e71e33848; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sune_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sor.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sor.c +new file mode 100644 +index 000000000..ea47baf40 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sor.c +@@ -0,0 +1,269 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0000007f; ++ *((int *)&__m128_op02) = 0x0000007f; ++ *((int *)&__m128_op01) = 0x0000007f; ++ *((int *)&__m128_op00) = 0x0000007f; ++ *((int *)&__m128_op13) = 0x3ff00000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xfffc0020; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x2757de72; ++ *((int *)&__m128_op02) = 0x33d771a3; ++ *((int *)&__m128_op01) = 0x166891d5; ++ *((int *)&__m128_op00) = 0x1e8b7eff; ++ *((int *)&__m128_op13) = 0x2757de72; ++ *((int *)&__m128_op12) = 0x33d771a3; ++ *((int *)&__m128_op11) = 0x166891d5; ++ *((int *)&__m128_op10) = 0x1e8b7eff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00fe00ff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000001; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xfffffffe; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0xffffff02; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x0000000d; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xfffffe03; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xfffffe03; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xbafebb00; ++ *((int *)&__m128_op12) = 0xffd500fe; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xbffffffe; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x80000000; ++ *((int *)&__m128_op02) = 0x80000000; ++ *((int *)&__m128_op01) = 0x80000000; ++ *((int *)&__m128_op00) = 0x80000000; ++ *((int *)&__m128_op13) = 0x000000ff; ++ *((int *)&__m128_op12) = 0x0000857a; ++ *((int *)&__m128_op11) = 0x05fafe01; ++ *((int *)&__m128_op10) = 0x01fe000e; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x7fff7fff; ++ *((int *)&__m128_op02) = 0x7fff7fff; ++ *((int *)&__m128_op01) = 0xbf6b8101; ++ *((int *)&__m128_op00) = 0x81018101; ++ *((int *)&__m128_op13) = 0xe3636363; ++ *((int *)&__m128_op12) = 0x63abdf16; ++ *((int *)&__m128_op11) = 0x41f8e080; ++ *((int *)&__m128_op10) = 0x16161198; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000005d5d; ++ *((unsigned long *)&__m128d_op11) = 0x08fdc221bfdb1927; ++ *((unsigned long *)&__m128d_op10) = 0x4303c67e9b7fb213; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x7fffffff7ffffffb; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000040002; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffffff000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000d00000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sor_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sun.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sun.c +new file mode 100644 +index 000000000..68cb5a52f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfcmp_sun.c +@@ -0,0 +1,335 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xe17fe003; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0x0000ffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffffff; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00190819; ++ *((int *)&__m128_op12) = 0x00190019; ++ *((int *)&__m128_op11) = 0x00190819; ++ *((int *)&__m128_op10) = 0x00190019; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xfe800000; ++ *((int *)&__m128_op00) = 0x00000001; ++ *((int *)&__m128_op13) = 0x7fffffff; ++ *((int *)&__m128_op12) = 0x82bb9784; ++ *((int *)&__m128_op11) = 0x7fffffff; ++ *((int *)&__m128_op10) = 0xc6bb97ac; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x7f3f0180; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0xa2321469; ++ *((int *)&__m128_op00) = 0x7fd03f7f; ++ *((int *)&__m128_op13) = 0x00000406; ++ *((int *)&__m128_op12) = 0x00000406; ++ *((int *)&__m128_op11) = 0x02020202; ++ *((int *)&__m128_op10) = 0x0202fe02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0xfffffff5; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000014; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000014; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0xfffc0004; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x67eb85b0; ++ *((int *)&__m128_op02) = 0xb2ebb001; ++ *((int *)&__m128_op01) = 0xc8847ef6; ++ *((int *)&__m128_op00) = 0xed3f2000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0x0002de46; ++ *((int *)&__m128_op02) = 0x682de060; ++ *((int *)&__m128_op01) = 0x09b50da6; ++ *((int *)&__m128_op00) = 0xe67b8fc0; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x084d12ce; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x24170000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0x00ffffff; ++ *((int *)&__m128_op00) = 0x00ffffff; ++ *((int *)&__m128_op13) = 0x0000feff; ++ *((int *)&__m128_op12) = 0x23560000; ++ *((int *)&__m128_op11) = 0x0000fd16; ++ *((int *)&__m128_op10) = 0x54860000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xfffffffe; ++ *((int *)&__m128_op00) = 0xfffff784; ++ *((int *)&__m128_op13) = 0x0177fff0; ++ *((int *)&__m128_op12) = 0xfffffff0; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x011ff8bc; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_s (__m128_op0, __m128_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0002000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0002000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op10) = 0x00ff00ff00ff00fe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128d_op00) = 0x000000007fff7fff; ++ *((unsigned long *)&__m128d_op11) = 0xfffffffffffff800; ++ *((unsigned long *)&__m128d_op10) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xfffebd06fffe820c; ++ *((unsigned long *)&__m128d_op10) = 0x7fff7ffe7fff3506; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x7ffffffeffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128d_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128d_op11) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000000000002f; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000029; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000003a24; ++ *((unsigned long *)&__m128d_op10) = 0x003dbe88077c78c1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128d_op00) = 0x0001fffe0001fefc; ++ *((unsigned long *)&__m128d_op11) = 0x0007000000050000; ++ *((unsigned long *)&__m128d_op10) = 0x0003000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfcmp_sun_d (__m128d_op0, __m128d_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vfmadd-vfnmadd-vld.patch
Added
@@ -0,0 +1,1412 @@ +From 5cc6bce7753e1029149839d58ed81f046087ad31 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 15:05:09 +0800 +Subject: PATCH 098/124 LoongArch: Add tests for SX vector + vfmadd/vfnmadd/vld/vst instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vfmadd_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfmadd_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfnmadd_d.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfnmadd_s.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vld.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vst.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vfmadd_d.c | 251 ++++++++++++ + .../loongarch/vector/lsx/lsx-vfmadd_s.c | 381 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vfnmadd_d.c | 196 +++++++++ + .../loongarch/vector/lsx/lsx-vfnmadd_s.c | 381 ++++++++++++++++++ + .../gcc.target/loongarch/vector/lsx/lsx-vld.c | 62 +++ + .../gcc.target/loongarch/vector/lsx/lsx-vst.c | 70 ++++ + 6 files changed, 1341 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_d.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_s.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vld.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vst.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_d.c +new file mode 100644 +index 000000000..c5de1ac7a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_d.c +@@ -0,0 +1,251 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x8a228acac14e440a; ++ *((unsigned long *)&__m128d_op10) = 0xc77c47cdc0f16549; ++ *((unsigned long *)&__m128d_op21) = 0xffffffffd24271c4; ++ *((unsigned long *)&__m128d_op20) = 0x2711bad1e8e309ed; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffd24271c4; ++ *((unsigned long *)&__m128d_result0) = 0x2711bad1e8e309ed; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000040400000383; ++ *((unsigned long *)&__m128d_op00) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128d_op11) = 0x0000040400000383; ++ *((unsigned long *)&__m128d_op10) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128d_op21) = 0x0000000001000001; ++ *((unsigned long *)&__m128d_op20) = 0x0001000100000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000001000001; ++ *((unsigned long *)&__m128d_result0) = 0xffffe000ffff1fff; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x00000000003f80b0; ++ *((unsigned long *)&__m128d_op10) = 0x00000000ff800000; ++ *((unsigned long *)&__m128d_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0080200000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000401000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000080000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000080000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000080000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000080000000000; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000000000001e; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128d_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op10) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m128d_op21) = 0xfffb00fdfdf7ffff; ++ *((unsigned long *)&__m128d_op20) = 0xfff8000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfffb00fdfdf7ffff; ++ *((unsigned long *)&__m128d_result0) = 0xfff8000000000000; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000009000900; ++ *((unsigned long *)&__m128d_op20) = 0x0000000009000900; ++ *((unsigned long *)&__m128d_result1) = 0x0000000009000900; ++ *((unsigned long *)&__m128d_result0) = 0x0000000009000900; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m128d_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x9c83e21a22001818; ++ *((unsigned long *)&__m128d_op00) = 0xdd3b8b02563b2d7b; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x7f7f7f007f7f7f00; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x7f7f7f007f7f7f00; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128d_op00) = 0xff01e41ffff0ffff; ++ *((unsigned long *)&__m128d_op11) = 0x5555000054100000; ++ *((unsigned long *)&__m128d_op10) = 0x5555000154100155; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vfmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000010; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000010; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfc01fcfefc02fdf7; ++ *((unsigned long *)&__m128d_op00) = 0xfe00fcfffe01fd01; ++ *((unsigned long *)&__m128d_op11) = 0xfc01fd1300000001; ++ *((unsigned long *)&__m128d_op10) = 0xfe00fd1400010000; ++ *((unsigned long *)&__m128d_op21) = 0xfc01fcfefc02fdf7; ++ *((unsigned long *)&__m128d_op20) = 0xfe00fcfffe01fd01; ++ *((unsigned long *)&__m128d_result1) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x7ff0000000000000; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000bd3d00000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0038d800ff000000; ++ *((unsigned long *)&__m128d_op10) = 0x00fffe00fffffe00; ++ *((unsigned long *)&__m128d_op21) = 0x8000008000008080; ++ *((unsigned long *)&__m128d_op20) = 0x8080800000800080; ++ *((unsigned long *)&__m128d_result1) = 0x0000008000008080; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x00ff80ff00ff80ff; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000900000009; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x000000007ff000ff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128d_op00) = 0x00000000fffffffe; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128d_result0) = 0x0000000000000000; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128d_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000100000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000103; ++ *((unsigned long *)&__m128d_result1) = 0x8000000100000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000103; ++ __m128d_out = __lsx_vfmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_s.c +new file mode 100644 +index 000000000..6b85e87bd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfmadd_s.c +@@ -0,0 +1,381 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000002; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000002; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x0028e0a1; ++ *((int *)&__m128_op02) = 0xa000a041; ++ *((int *)&__m128_op01) = 0x01000041; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x01000001; ++ *((int *)&__m128_op11) = 0x00010001; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x01000001; ++ *((int *)&__m128_op21) = 0xffffe000; ++ *((int *)&__m128_op20) = 0xffff1fff; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x01000001; ++ *((int *)&__m128_result1) = 0xffffe000; ++ *((int *)&__m128_result0) = 0xffff1fff; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x7f800000; ++ *((int *)&__m128_op02) = 0x7f800000; ++ *((int *)&__m128_op01) = 0x7f800000; ++ *((int *)&__m128_op00) = 0x7f800000; ++ *((int *)&__m128_op13) = 0x00000002; ++ *((int *)&__m128_op12) = 0x00000002; ++ *((int *)&__m128_op11) = 0x00000003; ++ *((int *)&__m128_op10) = 0x00000003; ++ *((int *)&__m128_op23) = 0x3fc00000; ++ *((int *)&__m128_op22) = 0x3fc00000; ++ *((int *)&__m128_op21) = 0x3fc00000; ++ *((int *)&__m128_op20) = 0x3fc00000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xc1bdceee; ++ *((int *)&__m128_op02) = 0x242070db; ++ *((int *)&__m128_op01) = 0xe8c7b756; ++ *((int *)&__m128_op00) = 0xd76aa478; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x7f400000; ++ *((int *)&__m128_op02) = 0x7f040000; ++ *((int *)&__m128_op01) = 0x7f020000; ++ *((int *)&__m128_op00) = 0x7f020000; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0x0014002c; ++ *((int *)&__m128_op11) = 0xfffefffe; ++ *((int *)&__m128_op10) = 0x003b0013; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0x3ea5016b; ++ *((int *)&__m128_result1) = 0xfffefffe; ++ *((int *)&__m128_result0) = 0x3f6fb04d; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x004f0080; ++ *((int *)&__m128_op02) = 0x004f0080; ++ *((int *)&__m128_op01) = 0x004f0080; ++ *((int *)&__m128_op00) = 0x004f0080; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x7fff7fff; ++ *((int *)&__m128_op22) = 0x7fff7fff; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7fff7fff; ++ *((int *)&__m128_result2) = 0x7fff7fff; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x3d3d3d3d; ++ *((int *)&__m128_op02) = 0x3d3d3d3d; ++ *((int *)&__m128_op01) = 0x3d3d3d3d; ++ *((int *)&__m128_op00) = 0x3d3d3d3d; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00100000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x0000bd3d; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00050005; ++ *((int *)&__m128_op12) = 0x00050005; ++ *((int *)&__m128_op11) = 0x00050005; ++ *((int *)&__m128_op10) = 0x00050005; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xe500c085; ++ *((int *)&__m128_op02) = 0xc000c005; ++ *((int *)&__m128_op01) = 0xe5c1a185; ++ *((int *)&__m128_op00) = 0xc48004c5; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffc000; ++ *((int *)&__m128_op10) = 0xffffc005; ++ *((int *)&__m128_op23) = 0xff550025; ++ *((int *)&__m128_op22) = 0x002a004b; ++ *((int *)&__m128_op21) = 0x00590013; ++ *((int *)&__m128_op20) = 0x005cffca; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xffffc000; ++ *((int *)&__m128_result0) = 0xffffc005; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00fe0001; ++ *((int *)&__m128_op12) = 0x00cf005f; ++ *((int *)&__m128_op11) = 0x7fff7fff; ++ *((int *)&__m128_op10) = 0x7fff7f00; ++ *((int *)&__m128_op23) = 0x5d7f5d00; ++ *((int *)&__m128_op22) = 0x7f6a007f; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x5d7f5d00; ++ *((int *)&__m128_result2) = 0x7f6a007f; ++ *((int *)&__m128_result1) = 0x7fff7fff; ++ *((int *)&__m128_result0) = 0x7fff7f00; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00680486; ++ *((int *)&__m128_op02) = 0xffffffda; ++ *((int *)&__m128_op01) = 0xffff913b; ++ *((int *)&__m128_op00) = 0xb9951901; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x01030103; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00200060; ++ *((int *)&__m128_op20) = 0x00200060; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0xffffffda; ++ *((int *)&__m128_result1) = 0xffff913b; ++ *((int *)&__m128_result0) = 0x001fed4d; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x001a001a; ++ *((int *)&__m128_op02) = 0x001a0008; ++ *((int *)&__m128_op01) = 0x001a001a; ++ *((int *)&__m128_op00) = 0x001a000b; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xff800001; ++ *((int *)&__m128_op10) = 0x0f800000; ++ *((int *)&__m128_op23) = 0xff800000; ++ *((int *)&__m128_op22) = 0xff800000; ++ *((int *)&__m128_op21) = 0xff800000; ++ *((int *)&__m128_op20) = 0xff800000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xffc00001; ++ *((int *)&__m128_result0) = 0xff800000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xfe3bfb01; ++ *((int *)&__m128_op02) = 0xfe3bfe01; ++ *((int *)&__m128_op01) = 0xfe03fe3f; ++ *((int *)&__m128_op00) = 0xfe01fa21; ++ *((int *)&__m128_op13) = 0xfe3bfb01; ++ *((int *)&__m128_op12) = 0xfe3bfe01; ++ *((int *)&__m128_op11) = 0xfe03fe3f; ++ *((int *)&__m128_op10) = 0xfe01fa21; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x7f800000; ++ *((int *)&__m128_result2) = 0x7f800000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x7f800000; ++ __m128_out = __lsx_vfmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffe001; ++ *((int *)&__m128_op02) = 0xffffe001; ++ *((int *)&__m128_op01) = 0xffffe001; ++ *((int *)&__m128_op00) = 0xffffe001; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0xffffe000; ++ *((int *)&__m128_op10) = 0x01ffe200; ++ *((int *)&__m128_op23) = 0x04040383; ++ *((int *)&__m128_op22) = 0x83838404; ++ *((int *)&__m128_op21) = 0x04040383; ++ *((int *)&__m128_op20) = 0x83838404; ++ *((int *)&__m128_result3) = 0xffffe001; ++ *((int *)&__m128_result2) = 0xffffe001; ++ *((int *)&__m128_result1) = 0xffffe001; ++ *((int *)&__m128_result0) = 0xffffe001; ++ __m128_out = __lsx_vfmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x18171615; ++ *((int *)&__m128_op02) = 0x17161514; ++ *((int *)&__m128_op01) = 0x16151413; ++ *((int *)&__m128_op00) = 0x151d3756; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x39412488; ++ *((int *)&__m128_op10) = 0x80000000; ++ *((int *)&__m128_op23) = 0x3ff00000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x40f3fa00; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0xbff00000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0xc0f3fa00; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000005; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x00000000; ++ *((int *)&__m128_result2) = 0x00000000; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x3ddc5dac; ++ *((int *)&__m128_op13) = 0xffffffff; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0x00000000; ++ *((int *)&__m128_result0) = 0x00000000; ++ __m128_out = __lsx_vfmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x63636b6a; ++ *((int *)&__m128_op02) = 0xfe486741; ++ *((int *)&__m128_op01) = 0x41f8e880; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0xe3636363; ++ *((int *)&__m128_op12) = 0x63abdf16; ++ *((int *)&__m128_op11) = 0x41f8e080; ++ *((int *)&__m128_op10) = 0x16161198; ++ *((int *)&__m128_op23) = 0x00c27580; ++ *((int *)&__m128_op22) = 0x00bccf42; ++ *((int *)&__m128_op21) = 0x00a975be; ++ *((int *)&__m128_op20) = 0x00accf03; ++ *((int *)&__m128_result3) = 0xff800000; ++ *((int *)&__m128_result2) = 0xff800000; ++ *((int *)&__m128_result1) = 0x4471fb84; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_d.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_d.c +new file mode 100644 +index 000000000..96b14aad6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_d.c +@@ -0,0 +1,196 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128d_op01) = 0xef0179a47c793879; ++ *((unsigned long *)&__m128d_op00) = 0x9f9e7e3e9ea3ff41; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128d_op20) = 0x1e801ffc7fc00000; ++ *((unsigned long *)&__m128d_result1) = 0xffc000007fc00000; ++ *((unsigned long *)&__m128d_result0) = 0x9e801ffc7fc00000; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128d_result1) = 0x8000ffff00000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000ffff00000000; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128d_op00) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128d_op11) = 0x0000000008800022; ++ *((unsigned long *)&__m128d_op10) = 0xffffffff00000001; ++ *((unsigned long *)&__m128d_op21) = 0xb8ec43befe38e64b; ++ *((unsigned long *)&__m128d_op20) = 0x6477d042343cce24; ++ *((unsigned long *)&__m128d_result1) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128d_result0) = 0xffffffbfffffffbf; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0xfffffffffffff000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000060000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfffffffffffff000; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xfffffffafffffffa; ++ *((unsigned long *)&__m128d_op00) = 0xfffffffafffffffa; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m128d_op10) = 0xf8f8f8f8f8f8f8f8; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000008000000080; ++ *((unsigned long *)&__m128d_op10) = 0x0000008000000080; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xff80ffa2fff0ff74; ++ *((unsigned long *)&__m128d_op00) = 0xff76ffd8ffe6ffaa; ++ *((unsigned long *)&__m128d_op11) = 0xff80ffa2fff0ff74; ++ *((unsigned long *)&__m128d_op10) = 0xff76ffd8ffe6ffaa; ++ *((unsigned long *)&__m128d_op21) = 0x0303030303030303; ++ *((unsigned long *)&__m128d_op20) = 0x0303030303030303; ++ *((unsigned long *)&__m128d_result1) = 0xfff0000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xfff0000000000000; ++ __m128d_out = __lsx_vfnmadd_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfnmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0001ffff00000000; ++ *((unsigned long *)&__m128d_op10) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfnmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128d_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128d_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128d_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x3c600000ff800000; ++ *((unsigned long *)&__m128d_result0) = 0xfffffffffffffffe; ++ __m128d_out = __lsx_vfnmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x000000000000000d; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x00000000b5207f80; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x00000000b5207f80; ++ __m128d_out = __lsx_vfnmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0xffffffffffffffff; ++ __m128d_out = __lsx_vfnmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op11) = 0x0000000009000900; ++ *((unsigned long *)&__m128d_op10) = 0x0000000009000900; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x8000000000000000; ++ __m128d_out = __lsx_vfnmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ *((unsigned long *)&__m128d_op01) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128d_op00) = 0x00a975be00accf03; ++ *((unsigned long *)&__m128d_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128d_op20) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128d_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128d_result0) = 0x00000000ffffffff; ++ __m128d_out = __lsx_vfnmsub_d (__m128d_op0, __m128d_op1, __m128d_op2); ++ ASSERTEQ_64 (__LINE__, __m128d_result, __m128d_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_s.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_s.c +new file mode 100644 +index 000000000..bf8414b49 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfnmadd_s.c +@@ -0,0 +1,381 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xfffffffe; ++ *((int *)&__m128_op00) = 0xbe6ed565; ++ *((int *)&__m128_op13) = 0x195f307a; ++ *((int *)&__m128_op12) = 0x5d04acbb; ++ *((int *)&__m128_op11) = 0x6a1a3fbb; ++ *((int *)&__m128_op10) = 0x3c90260e; ++ *((int *)&__m128_op23) = 0xffffffff; ++ *((int *)&__m128_op22) = 0xffffffff; ++ *((int *)&__m128_op21) = 0xfffffffe; ++ *((int *)&__m128_op20) = 0xbe6ed565; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xfffffffe; ++ *((int *)&__m128_result0) = 0x3e730941; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffffffff; ++ *((int *)&__m128_op01) = 0xffffffff; ++ *((int *)&__m128_op00) = 0xff01ff01; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0xffffffff; ++ *((int *)&__m128_op22) = 0xffffffff; ++ *((int *)&__m128_op21) = 0xffffffff; ++ *((int *)&__m128_op20) = 0xff01ff01; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0xffffffff; ++ *((int *)&__m128_result0) = 0x7f01ff01; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0xffffffff; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0xffffffff; ++ *((int *)&__m128_op23) = 0x00307028; ++ *((int *)&__m128_op22) = 0x003f80b0; ++ *((int *)&__m128_op21) = 0x0040007f; ++ *((int *)&__m128_op20) = 0xff800000; ++ *((int *)&__m128_result3) = 0x80307028; ++ *((int *)&__m128_result2) = 0xffffffff; ++ *((int *)&__m128_result1) = 0x8040007f; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000049; ++ *((int *)&__m128_op02) = 0x0000004d; ++ *((int *)&__m128_op01) = 0x00000001; ++ *((int *)&__m128_op00) = 0xffffffff; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000001; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000001; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x80000001; ++ *((int *)&__m128_result0) = 0xffffffff; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffffffff; ++ *((int *)&__m128_op02) = 0xffff0000; ++ *((int *)&__m128_op01) = 0x00ff0000; ++ *((int *)&__m128_op00) = 0x00ff0000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000800; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0xffffffff; ++ *((int *)&__m128_op22) = 0xfffff800; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xfffff800; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00030000; ++ *((int *)&__m128_op02) = 0x00010000; ++ *((int *)&__m128_op01) = 0x00020000; ++ *((int *)&__m128_op00) = 0x00010000; ++ *((int *)&__m128_op13) = 0x3f800000; ++ *((int *)&__m128_op12) = 0x3f800000; ++ *((int *)&__m128_op11) = 0x3f800000; ++ *((int *)&__m128_op10) = 0x3f800000; ++ *((int *)&__m128_op23) = 0x00030000; ++ *((int *)&__m128_op22) = 0x00010000; ++ *((int *)&__m128_op21) = 0x00020000; ++ *((int *)&__m128_op20) = 0x00010000; ++ *((int *)&__m128_result3) = 0x80060000; ++ *((int *)&__m128_result2) = 0x80020000; ++ *((int *)&__m128_result1) = 0x80040000; ++ *((int *)&__m128_result0) = 0x80020000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000008; ++ *((int *)&__m128_op02) = 0x97957687; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000408; ++ *((int *)&__m128_op13) = 0x00000008; ++ *((int *)&__m128_op12) = 0x97957687; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000408; ++ *((int *)&__m128_op23) = 0x00010001; ++ *((int *)&__m128_op22) = 0x00010001; ++ *((int *)&__m128_op21) = 0x00010001; ++ *((int *)&__m128_op20) = 0x04000800; ++ *((int *)&__m128_result3) = 0x80010001; ++ *((int *)&__m128_result2) = 0x80010001; ++ *((int *)&__m128_result1) = 0x80010001; ++ *((int *)&__m128_result0) = 0x84000800; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xffc2ffe7; ++ *((int *)&__m128_op02) = 0x00000007; ++ *((int *)&__m128_op01) = 0x0000ffc1; ++ *((int *)&__m128_op00) = 0x00010001; ++ *((int *)&__m128_op13) = 0xffc2ffe7; ++ *((int *)&__m128_op12) = 0x00000007; ++ *((int *)&__m128_op11) = 0x0000ffc1; ++ *((int *)&__m128_op10) = 0x00010001; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x000ffc2f; ++ *((int *)&__m128_op21) = 0x00201df0; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0xffc2ffe7; ++ *((int *)&__m128_result2) = 0x800ffc2f; ++ *((int *)&__m128_result1) = 0x80201df0; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000005; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x80808080; ++ *((int *)&__m128_op02) = 0x80808080; ++ *((int *)&__m128_op01) = 0x80808080; ++ *((int *)&__m128_op00) = 0x80800008; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x31313131; ++ *((int *)&__m128_op00) = 0x31313131; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x31313131; ++ *((int *)&__m128_op10) = 0x31313131; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000008; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000008; ++ *((int *)&__m128_result1) = 0xa2f54a1e; ++ *((int *)&__m128_result0) = 0xa2f54a1e; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmadd_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0xa486c90f; ++ *((int *)&__m128_op02) = 0x157ca12e; ++ *((int *)&__m128_op01) = 0x58bcc201; ++ *((int *)&__m128_op00) = 0x2e635d65; ++ *((int *)&__m128_op13) = 0x6d564875; ++ *((int *)&__m128_op12) = 0xf8760005; ++ *((int *)&__m128_op11) = 0x8dc5a4d1; ++ *((int *)&__m128_op10) = 0x79ffa22f; ++ *((int *)&__m128_op23) = 0xffffffff; ++ *((int *)&__m128_op22) = 0xd2436487; ++ *((int *)&__m128_op21) = 0x0fa96b88; ++ *((int *)&__m128_op20) = 0x5f94ab13; ++ *((int *)&__m128_result3) = 0xffffffff; ++ *((int *)&__m128_result2) = 0xd24271c4; ++ *((int *)&__m128_result1) = 0x2711bad1; ++ *((int *)&__m128_result0) = 0xe8e309ed; ++ __m128_out = __lsx_vfnmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x00000000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x80000000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x007ffd00; ++ *((int *)&__m128_op20) = 0x01400840; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x007ffd00; ++ *((int *)&__m128_result0) = 0x01400840; ++ __m128_out = __lsx_vfnmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0x00000000; ++ *((int *)&__m128_op22) = 0x00000000; ++ *((int *)&__m128_op21) = 0x7f800000; ++ *((int *)&__m128_op20) = 0x00000000; ++ *((int *)&__m128_result3) = 0x80000000; ++ *((int *)&__m128_result2) = 0x80000000; ++ *((int *)&__m128_result1) = 0x7f800000; ++ *((int *)&__m128_result0) = 0x80000000; ++ __m128_out = __lsx_vfnmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ *((int *)&__m128_op03) = 0x00000000; ++ *((int *)&__m128_op02) = 0x00000000; ++ *((int *)&__m128_op01) = 0x00000000; ++ *((int *)&__m128_op00) = 0x00000000; ++ *((int *)&__m128_op13) = 0x00000000; ++ *((int *)&__m128_op12) = 0x00000000; ++ *((int *)&__m128_op11) = 0x00000000; ++ *((int *)&__m128_op10) = 0x00000000; ++ *((int *)&__m128_op23) = 0xcd636363; ++ *((int *)&__m128_op22) = 0xcd636363; ++ *((int *)&__m128_op21) = 0xcd636363; ++ *((int *)&__m128_op20) = 0xcd636363; ++ *((int *)&__m128_result3) = 0xcd636363; ++ *((int *)&__m128_result2) = 0xcd636363; ++ *((int *)&__m128_result1) = 0xcd636363; ++ *((int *)&__m128_result0) = 0xcd636363; ++ __m128_out = __lsx_vfnmsub_s (__m128_op0, __m128_op1, __m128_op2); ++ ASSERTEQ_32 (__LINE__, __m128_result, __m128_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vld.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vld.c +new file mode 100644 +index 000000000..7cd9abb7c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vld.c +@@ -0,0 +1,62 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_result0) = 0x3ab7a3fc47a5c31a; ++ __m128i_out = __lsx_vld ((unsigned long *)&__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_result0) = 0x3ab7a3fc47a5c31a; ++ __m128i_out = __lsx_vldx ((unsigned long *)&__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0xc3c3c3c3c3c3c3c3; ++ *((unsigned long *)&__m128i_result0) = 0xc3c3c3c3c3c3c3c3; ++ __m128i_out = __lsx_vldrepl_b ((unsigned long *)&__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0xc31ac31ac31ac31a; ++ *((unsigned long *)&__m128i_result0) = 0xc31ac31ac31ac31a; ++ __m128i_out = __lsx_vldrepl_h ((unsigned long *)&__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x47a5c31a47a5c31a; ++ *((unsigned long *)&__m128i_result0) = 0x47a5c31a47a5c31a; ++ __m128i_out = __lsx_vldrepl_w ((unsigned long *)&__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result0) = 0x3ab7a3fc47a5c31a; ++ __m128i_out = __lsx_vldrepl_d ((unsigned long *)&__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vst.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vst.c +new file mode 100644 +index 000000000..8afdffa50 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vst.c +@@ -0,0 +1,70 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x0; ++ *((unsigned long *)&__m128i_result0) = 0x0; ++ __lsx_vst (__m128i_op0, (unsigned long *)&__m128i_result, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_op0, __m128i_result); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x0; ++ *((unsigned long *)&__m128i_result0) = 0x0; ++ __lsx_vstx (__m128i_op0, (unsigned long *)&__m128i_result, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_op0, __m128i_result); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x0; ++ *((unsigned long *)&__m128i_result0) = 0x05; ++ *((unsigned long *)&__m128i_out1) = 0x0; ++ *((unsigned long *)&__m128i_out0) = 0x0; ++ __lsx_vstelm_b (__m128i_op0, (unsigned long *)&__m128i_out, 0x0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x0; ++ *((unsigned long *)&__m128i_result0) = 0x5c05; ++ *((unsigned long *)&__m128i_out1) = 0x0; ++ *((unsigned long *)&__m128i_out0) = 0x0; ++ __lsx_vstelm_h (__m128i_op0, (unsigned long *)&__m128i_out, 0x0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x0; ++ *((unsigned long *)&__m128i_result0) = 0xc9d85c05; ++ *((unsigned long *)&__m128i_out1) = 0x0; ++ *((unsigned long *)&__m128i_out0) = 0x0; ++ __lsx_vstelm_w (__m128i_op0, (unsigned long *)&__m128i_out, 0x0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0x0; ++ *((unsigned long *)&__m128i_result0) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_out1) = 0x0; ++ *((unsigned long *)&__m128i_out0) = 0x0; ++ __lsx_vstelm_d (__m128i_op0, (unsigned long *)&__m128i_out, 0x0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vfrstp-vfrstpi-vse.patch
Added
@@ -0,0 +1,3926 @@ +From 06a477566d282d87ce187901904c4bae2c2c4aaf Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 11:28:29 +0800 +Subject: PATCH 094/124 LoongArch: Add tests for SX vector + vfrstp/vfrstpi/vseq/vseqi/vsle /vslei/vslt/vslti instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vfrstp.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vfrstpi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vseq.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vseqi.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsle-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsle-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vslei-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vslei-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vslt-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vslt-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vslti-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vslti-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vfrstp.c | 218 ++++++++ + .../loongarch/vector/lsx/lsx-vfrstpi.c | 209 ++++++++ + .../loongarch/vector/lsx/lsx-vseq.c | 470 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vseqi.c | 328 ++++++++++++ + .../loongarch/vector/lsx/lsx-vsle-1.c | 290 +++++++++++ + .../loongarch/vector/lsx/lsx-vsle-2.c | 444 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vslei-1.c | 258 ++++++++++ + .../loongarch/vector/lsx/lsx-vslei-2.c | 293 +++++++++++ + .../loongarch/vector/lsx/lsx-vslt-1.c | 434 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vslt-2.c | 236 +++++++++ + .../loongarch/vector/lsx/lsx-vslti-1.c | 328 ++++++++++++ + .../loongarch/vector/lsx/lsx-vslti-2.c | 293 +++++++++++ + 12 files changed, 3801 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstp.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstpi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseq.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseqi.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstp.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstp.c +new file mode 100644 +index 000000000..ac0ade8b1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstp.c +@@ -0,0 +1,218 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe07e5fefefdddfe; ++ *((unsigned long *)&__m128i_op00) = 0x00020100fedd0c00; ++ *((unsigned long *)&__m128i_op11) = 0x0005000501800005; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfe07e5fefefdddfe; ++ *((unsigned long *)&__m128i_result0) = 0x00020100fedd0008; ++ __m128i_out = __lsx_vfrstp_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op10) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op21) = 0x03ff03ff03ff03ff; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0e7ffffc01fffffc; ++ *((unsigned long *)&__m128i_op00) = 0x0000000003f803f4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0e7ffffc01fffffc; ++ *((unsigned long *)&__m128i_op20) = 0x0000000003f803f4; ++ *((unsigned long *)&__m128i_result1) = 0x0e7ffffc01fffffc; ++ *((unsigned long *)&__m128i_result0) = 0x0000001003f803f4; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x000000020000007d; ++ *((unsigned long *)&__m128i_op11) = 0x0000746400016388; ++ *((unsigned long *)&__m128i_op10) = 0x0000586100015567; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0800000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x000000020000007d; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0008; ++ __m128i_out = __lsx_vfrstp_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x61608654a2d4f6da; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ff08ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x36fbdfdcffdcffdc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000008140c80; ++ *((unsigned long *)&__m128i_op21) = 0x1f1f1f1f1f1f1f00; ++ *((unsigned long *)&__m128i_op20) = 0x1f1f1f27332b9f00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x36fbdfdcffdc0008; ++ __m128i_out = __lsx_vfrstp_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000aaaa; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000545cab1d; ++ *((unsigned long *)&__m128i_op10) = 0x0000000081a83bea; ++ *((unsigned long *)&__m128i_op21) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op20) = 0x00d3007c014e00bd; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000aaaa; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000003a0000003a; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_result0) = 0x37c0001000000008; ++ __m128i_out = __lsx_vfrstp_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080800008; ++ __m128i_out = __lsx_vfrstp_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1f1f1f1f1f1f1f1f; ++ *((unsigned long *)&__m128i_op00) = 0x1f1f1f1f1f1f1f1f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op21) = 0x1f1f1f1f1f1f1f1f; ++ *((unsigned long *)&__m128i_op20) = 0x1f1f1f1f1f1f1f1f; ++ *((unsigned long *)&__m128i_result1) = 0x00081f1f1f1f1f1f; ++ *((unsigned long *)&__m128i_result0) = 0x1f1f1f1f1f1f1f1f; ++ __m128i_out = __lsx_vfrstp_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000400080003fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000bc2000007e10; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000400080003fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000bc2000007e04; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_op00) = 0x0a753500950fa306; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff14eb54ab; ++ *((unsigned long *)&__m128i_op10) = 0x14ea6a002a406a00; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x00007fff7fff8000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000a752a55; ++ *((unsigned long *)&__m128i_result0) = 0x0a753500950fa306; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x02b010f881a281a2; ++ *((unsigned long *)&__m128i_op00) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_op11) = 0x02b010f881a281a2; ++ *((unsigned long *)&__m128i_op10) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x02b010f881a281a2; ++ *((unsigned long *)&__m128i_result0) = 0x27b169bbb8140001; ++ __m128i_out = __lsx_vfrstp_h (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op10) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op21) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op20) = 0x0000000000000155; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff100000000000; ++ __m128i_out = __lsx_vfrstp_b (__m128i_op0, __m128i_op1, __m128i_op2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstpi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstpi.c +new file mode 100644 +index 000000000..a2b110f21 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vfrstpi.c +@@ -0,0 +1,209 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0027002a00030018; ++ *((unsigned long *)&__m128i_op00) = 0x7f4300177f7a7f59; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0027002a00080018; ++ *((unsigned long *)&__m128i_result0) = 0x7f4300177f7a7f59; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000007f00000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000401000001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000110000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000007f00000004; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000800000000; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x75b043c4d17db125; ++ *((unsigned long *)&__m128i_op00) = 0xeef8227b4f8017b1; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x027c027c000027c0; ++ *((unsigned long *)&__m128i_result1) = 0x75b043c4007db125; ++ *((unsigned long *)&__m128i_result0) = 0xeef8227b4f8017b1; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x03c0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x03c0038000000380; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff000000ff00; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000010a000b; ++ *((unsigned long *)&__m128i_op11) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00ffff000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000010a000b; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000009; ++ *((unsigned long *)&__m128i_op00) = 0x5b35342c979955da; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000009; ++ *((unsigned long *)&__m128i_result0) = 0x5b35342c970455da; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0010000000000000; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00d3012b015700bb; ++ *((unsigned long *)&__m128i_op00) = 0x0001002affca0070; ++ *((unsigned long *)&__m128i_op11) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x00d3012b015700bb; ++ *((unsigned long *)&__m128i_result0) = 0x00010000ffca0070; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffe0001; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000bf; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000002bb; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00080000fffe0001; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000545cffffab1d; ++ *((unsigned long *)&__m128i_op00) = 0xffff81a800003bea; ++ *((unsigned long *)&__m128i_op11) = 0x13f9c5b60028a415; ++ *((unsigned long *)&__m128i_op10) = 0x545cab1d81a83bea; ++ *((unsigned long *)&__m128i_result1) = 0x0000545cffff0001; ++ *((unsigned long *)&__m128i_result0) = 0xffff81a800003bea; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001b; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0008000000000000; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x379674c000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x379674c000000000; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001a001a001a000b; ++ *((unsigned long *)&__m128i_op00) = 0x001a001a001a000b; ++ *((unsigned long *)&__m128i_op11) = 0x001a001a001a000b; ++ *((unsigned long *)&__m128i_op10) = 0x001a001a001a000b; ++ *((unsigned long *)&__m128i_result1) = 0x001a001a001a0008; ++ *((unsigned long *)&__m128i_result0) = 0x001a001a001a000b; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x02f3030303030303; ++ *((unsigned long *)&__m128i_op11) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_op10) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x02f3030303100303; ++ __m128i_out = __lsx_vfrstpi_b (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_op00) = 0x00007770ffff941d; ++ *((unsigned long *)&__m128i_op11) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_op10) = 0x00007770ffff941d; ++ *((unsigned long *)&__m128i_result1) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_result0) = 0x00007770ffff941d; ++ __m128i_out = __lsx_vfrstpi_h (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseq.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseq.c +new file mode 100644 +index 000000000..4362941ab +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseq.c +@@ -0,0 +1,470 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ed0008005e00a2; ++ *((unsigned long *)&__m128i_op00) = 0x007a007600150077; ++ *((unsigned long *)&__m128i_op11) = 0x00ed0008005e00a2; ++ *((unsigned long *)&__m128i_op10) = 0x007a007600150077; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c63636363; ++ *((unsigned long *)&__m128i_op11) = 0xfff489b693120950; ++ *((unsigned long *)&__m128i_op10) = 0xfffc45a851c40c18; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0xfda9b23a624082fd; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff7f800000; ++ *((unsigned long *)&__m128i_op00) = 0x2d1da85b7f800000; ++ *((unsigned long *)&__m128i_op11) = 0x7505853d654185f5; ++ *((unsigned long *)&__m128i_op10) = 0x01010000fefe0101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1fc000001fc00000; ++ *((unsigned long *)&__m128i_op00) = 0x1fc000001fc00000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000000010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff00000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000067400002685; ++ *((unsigned long *)&__m128i_op11) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op10) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_op00) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9795698585057dec; ++ *((unsigned long *)&__m128i_op00) = 0x87f82867431a1d08; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x1149a96eb1a08000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e19181716; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op10) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffe1ffffffe1; ++ *((unsigned long *)&__m128i_op00) = 0xffffffe1ffffffe1; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_op00) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_op11) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_op10) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0202020202020202; ++ *((unsigned long *)&__m128i_op10) = 0x363d753d50155c0a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000800080; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_op00) = 0x0f0f0f0f00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000fffe01fd02; ++ *((unsigned long *)&__m128i_result1) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x000000ffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff00; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_op00) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_op11) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_op10) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x5b5b5b5aadadadad; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000052525253; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff00ffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff00ffffffffff; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_op00) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_op11) = 0x33f5c2d7d9f5d800; ++ *((unsigned long *)&__m128i_op10) = 0xe4c23ffb002a3a22; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000004870ba0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op10) = 0x0000000044470000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff0000ffff; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000404040; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result1) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000005c000000b2; ++ *((unsigned long *)&__m128i_op10) = 0x0000007600000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffffffff; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c0dec4d1; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vseq_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m128i_op00) = 0x0000001000000048; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffeffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000f50000000900; ++ *((unsigned long *)&__m128i_op10) = 0x0000090900000998; ++ *((unsigned long *)&__m128i_result1) = 0xffff00ffffff00ff; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7f7f7f007f7f7f00; ++ *((unsigned long *)&__m128i_op11) = 0xf2c97aaa7d8fa270; ++ *((unsigned long *)&__m128i_op10) = 0x0b73e427f7cfcb88; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff01fe03ff01fe03; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseq_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vseq_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseqi.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseqi.c +new file mode 100644 +index 000000000..c16a291de +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vseqi.c +@@ -0,0 +1,328 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff800000c3080002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfedb27095b6bff95; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op00) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000040000000400; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0010000000100000; ++ *((unsigned long *)&__m128i_op00) = 0x0010000000100000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000001000f00fe00; ++ *((unsigned long *)&__m128i_op00) = 0x0000017fff00fe7f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x007ffd0001400840; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff01ff010000ff7d; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000fffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffa6ff91fdd8ef77; ++ *((unsigned long *)&__m128i_op00) = 0x061202bffb141c38; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000fef01000f27ca; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2a29282726252423; ++ *((unsigned long *)&__m128i_op00) = 0x2221201f1e1d1c1b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff80ff00ff80ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x9c7c266e71768fa4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0313100003131000; ++ *((unsigned long *)&__m128i_op00) = 0x0313100003131000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001a0000000b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_b (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000002a001a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000001a000b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x05f5e2320605e1e2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_d (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0d060d060d060d06; ++ *((unsigned long *)&__m128i_op00) = 0x0d060d060d060d06; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff2356fe165486; ++ *((unsigned long *)&__m128i_op00) = 0x5efeb3165bd7653d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vseqi_w (__m128i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vseqi_h (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-1.c +new file mode 100644 +index 000000000..a26eb0a3d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-1.c +@@ -0,0 +1,290 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_op10) = 0x004200a000200000; ++ *((unsigned long *)&__m128i_result1) = 0xffffff00ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffff00ffffffff; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000aaaaaaaa; ++ *((unsigned long *)&__m128i_op00) = 0x00000000aaab555b; ++ *((unsigned long *)&__m128i_op11) = 0x00000000aaaaaaaa; ++ *((unsigned long *)&__m128i_op10) = 0x00000000aaab555b; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000897957687; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000408; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000ed0e0; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000004080; ++ *((unsigned long *)&__m128i_result1) = 0xffffff00ffff00ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff00; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004cff8fffde0051; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff00; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000040400000404; ++ *((unsigned long *)&__m128i_op10) = 0x0000040400000404; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000003e2; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff00ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000501000002; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100000008; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_op11) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_op10) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0000; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x55aa55aa55aa55ab; ++ *((unsigned long *)&__m128i_op00) = 0xaa55555655aaaaa8; ++ *((unsigned long *)&__m128i_op11) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_op10) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff00000000ffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x6b6c4beb636443e3; ++ *((unsigned long *)&__m128i_op10) = 0x0507070805070708; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffefffefffefffef; ++ *((unsigned long *)&__m128i_op10) = 0xffefffefffefffef; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000085af0000b000; ++ *((unsigned long *)&__m128i_op10) = 0x00017ea200002000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vsle_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffc0800000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128i_op00) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0100000001000000; ++ *((unsigned long *)&__m128i_op00) = 0x0100000001000000; ++ *((unsigned long *)&__m128i_op11) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_op10) = 0x0040004000400040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_op10) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000005003a; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-2.c +new file mode 100644 +index 000000000..15c6cedc2 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsle-2.c +@@ -0,0 +1,444 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0005000400000004; ++ *((unsigned long *)&__m128i_op00) = 0x0400001001150404; ++ *((unsigned long *)&__m128i_op11) = 0x0005000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0400001001150404; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op10) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0100000001000100; ++ *((unsigned long *)&__m128i_op00) = 0x0100010000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000490000004d; ++ *((unsigned long *)&__m128i_op10) = 0x00000001ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00ffffff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ffffffffff; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000020000000200; ++ *((unsigned long *)&__m128i_op00) = 0x0000020000000200; ++ *((unsigned long *)&__m128i_op11) = 0x0000020000000200; ++ *((unsigned long *)&__m128i_op10) = 0x0000020000000200; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000008680f1ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0280000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x00ffffff00000000; ++ __m128i_out = __lsx_vsle_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000036280000; ++ *((unsigned long *)&__m128i_op10) = 0x42a0000042a02000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff80ff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xffff80000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff0600d50e9ef518; ++ *((unsigned long *)&__m128i_op00) = 0xffefffa8007c000f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000001faea9ec; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100007f01; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfbfbfb17fbfb38ea; ++ *((unsigned long *)&__m128i_op00) = 0xfbfb47fbfbfb0404; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000005fffa; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100fe000100fe; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00001fff00001fff; ++ *((unsigned long *)&__m128i_op00) = 0x00000003fffffffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000800080; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000040002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000bffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000007f7f7f; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000011ff040; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op10) = 0x001000100010c410; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffcafff8ff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000a0; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffcafff8ff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000a0; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_op00) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_op11) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op10) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000007f0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000007f0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000ed0e0; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000004080; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000ed0e0; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000004080; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0x8); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0003030000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op11) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op10) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00ff00fffbfffc; ++ *((unsigned long *)&__m128i_op00) = 0xff01ff1100000048; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsle_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-1.c +new file mode 100644 +index 000000000..0e72a33dd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-1.c +@@ -0,0 +1,258 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_b (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_op00) = 0x0f000d200e000c20; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_b (__m128i_op0, -6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_b (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000200008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffff00ffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffff00ffff; ++ __m128i_out = __lsx_vslei_b (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00ffffff00ffffff; ++ __m128i_out = __lsx_vslei_b (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111113111111141; ++ *((unsigned long *)&__m128i_op00) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000101; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff00008080; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x31dc2cc1bc268c93; ++ *((unsigned long *)&__m128i_op00) = 0x9c4d53d855f89514; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff00000000ffff; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_h (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_w (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_w (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fc000003fc00000; ++ *((unsigned long *)&__m128i_op00) = 0x3fc000003fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_w (__m128i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_w (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_op00) = 0xffff6080ffff4417; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_w (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd78cfd70b5f65d76; ++ *((unsigned long *)&__m128i_op00) = 0x5779108fdedda7e4; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslei_w (__m128i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_w (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000001fc1a568; ++ *((unsigned long *)&__m128i_op00) = 0x02693fe0e7beb077; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, -6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf1819b7c0732a6b6; ++ *((unsigned long *)&__m128i_op00) = 0xffb9917a6e7fffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0037ffc8d7ff2800; ++ *((unsigned long *)&__m128i_op00) = 0xff00ffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf03ef03ef03ef03e; ++ *((unsigned long *)&__m128i_op00) = 0xf03ef03ef03ef03e; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_d (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-2.c +new file mode 100644 +index 000000000..685a1bb36 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslei-2.c +@@ -0,0 +1,293 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xd82480697f678077; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff489b693120950; ++ *((unsigned long *)&__m128i_op00) = 0xfffc45a851c40c18; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff00; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1268f057137a0267; ++ *((unsigned long *)&__m128i_op00) = 0x0048137ef886fae0; ++ *((unsigned long *)&__m128i_result1) = 0xff000000ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0xff00ff0000000000; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000202fe02; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff00ff; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_bu (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffff7a53; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffffffffffff; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ff00; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000f; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff0000; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001b4a00007808; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffffffffffff; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_hu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000003900; ++ *((unsigned long *)&__m128i_op00) = 0x68bcf93435ed25ed; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x00000000f0000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa2a2a2a3a2a2a2a3; ++ *((unsigned long *)&__m128i_op00) = 0xc605c000aedd0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_wu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00250023001c001d; ++ *((unsigned long *)&__m128i_op00) = 0x309d2f342a5d2b34; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslei_du (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-1.c +new file mode 100644 +index 000000000..15c96ccfe +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-1.c +@@ -0,0 +1,434 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007658000115de0; ++ *((unsigned long *)&__m128i_op00) = 0x001a8960001d2cc0; ++ *((unsigned long *)&__m128i_op11) = 0xffc000007fc00000; ++ *((unsigned long *)&__m128i_op10) = 0x9e801ffc7fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x000000ffff0000ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff00ff0000ff; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000040100; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000384; ++ *((unsigned long *)&__m128i_op10) = 0xe3f0200004003ffd; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff00ff00ff00; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000001ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff00; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f0101070101010f; ++ *((unsigned long *)&__m128i_op10) = 0x000000127f010116; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000ffffffffff; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000ffef0010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff0000ff0000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ff; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff00000000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff02000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000002a001a; ++ *((unsigned long *)&__m128i_op00) = 0x001a000b00000000; ++ *((unsigned long *)&__m128i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff001a00000000; ++ *((unsigned long *)&__m128i_op11) = 0x003fffc0ffc0003f; ++ *((unsigned long *)&__m128i_op10) = 0xffc0ffc0003f003f; ++ *((unsigned long *)&__m128i_result1) = 0x00ff0000000000ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ff00ff; ++ __m128i_out = __lsx_vslt_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op00) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op11) = 0x0403cfcf01c1595e; ++ *((unsigned long *)&__m128i_op10) = 0x837cd5db43fc55d4; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0004000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0004000000040000; ++ *((unsigned long *)&__m128i_op11) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_op10) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffefefffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffefefffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000080000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000080000000800; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_op00) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1748c4f9ed1a5870; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffff00000000ffff; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op11) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op10) = 0x0000000024170000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff000086bd; ++ *((unsigned long *)&__m128i_op00) = 0x0000ca000000c481; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000003e2; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00050eb00000fffa; ++ *((unsigned long *)&__m128i_op10) = 0x0000f8a50000f310; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000011f0000f040; ++ *((unsigned long *)&__m128i_op11) = 0x0177fff0fffffff0; ++ *((unsigned long *)&__m128i_op10) = 0x00000000011ff8bc; ++ *((unsigned long *)&__m128i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vslt_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op00) = 0x001000100010c410; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x800000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x00ffffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128i_op00) = 0x803f800080000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001f5400000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0002008360500088; ++ *((unsigned long *)&__m128i_op11) = 0x0000000400028000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000003ff8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000467fef81; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op10) = 0x9c9c9c9c63636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000003f800000; ++ *((unsigned long *)&__m128i_op00) = 0x4eede8494f000000; ++ *((unsigned long *)&__m128i_op11) = 0x1817161517161514; ++ *((unsigned long *)&__m128i_op10) = 0x1615141315141312; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_op10) = 0x0fff0fff7f800fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000fffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0010000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-2.c +new file mode 100644 +index 000000000..e8d69f0e9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslt-2.c +@@ -0,0 +1,236 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0007658000115de0; ++ *((unsigned long *)&__m128i_op10) = 0x001a8960001d2cc0; ++ *((unsigned long *)&__m128i_result1) = 0x00ffffff00ffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ffffff; ++ __m128i_out = __lsx_vslt_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_op10) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff00; ++ __m128i_out = __lsx_vslt_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op00) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffff359f358; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffff359f358; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffff00ff00; ++ __m128i_out = __lsx_vslt_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x317fce80317fce80; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000fffe0000fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vslt_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007658000115de0; ++ *((unsigned long *)&__m128i_op00) = 0x001a8960001d2cc0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfe80ffffffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001c88bf0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000320; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000007730; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x4050000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x6363636163636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslt_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff8f8dada; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff01018888; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000145ad; ++ *((unsigned long *)&__m128i_op10) = 0x0000000300003e6e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e19181716; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00005dcbe7e830c0; ++ *((unsigned long *)&__m128i_op10) = 0x03f21e0114bf19da; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x5e695e95e1cb5a01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0313100003131000; ++ *((unsigned long *)&__m128i_op10) = 0x0313100003131000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000010a7; ++ *((unsigned long *)&__m128i_op00) = 0x0000000046ebaa2c; ++ *((unsigned long *)&__m128i_op11) = 0xf1f1f1f149ed7273; ++ *((unsigned long *)&__m128i_op10) = 0xf1f1f1f1865e65a1; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslt_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00050eb00000fffa; ++ *((unsigned long *)&__m128i_op00) = 0x0000f8a50000f310; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslt_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-1.c +new file mode 100644 +index 000000000..5bf3ce6e8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-1.c +@@ -0,0 +1,328 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslti_b (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00feff0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00feff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ffff0000000000; ++ __m128i_out = __lsx_vslti_b (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffefffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffefffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_b (__m128i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_b (__m128i_op0, 8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_b (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_b (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_b (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x807f7f8000ffff00; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff00feff00; ++ *((unsigned long *)&__m128i_result1) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff0000ffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x195f307a5d04acbb; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a3a3a3b3a3a3a3a; ++ *((unsigned long *)&__m128i_op00) = 0x3a3a00003a3a0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff00000000; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_h (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5ff6a0a40ea8f47c; ++ *((unsigned long *)&__m128i_op00) = 0x5ff6a0a40e9da42a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_op00) = 0x004200a000200001; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xd82480697f678077; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffe15; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffe15; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffc000ffffc005; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0006000100040001; ++ *((unsigned long *)&__m128i_op00) = 0x00010002ffff0105; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa000308000008002; ++ *((unsigned long *)&__m128i_op00) = 0x0500847b00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vslti_w (__m128i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000005e695e95; ++ *((unsigned long *)&__m128i_op00) = 0x5e695e96c396b402; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x0103000201030002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000455555555; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x63636b6afe486741; ++ *((unsigned long *)&__m128i_op00) = 0x41f8e880ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_d (__m128i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-2.c +new file mode 100644 +index 000000000..768df528f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslti-2.c +@@ -0,0 +1,293 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x003f800000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff0000ffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xff0000ffffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000008a0000008a; ++ *((unsigned long *)&__m128i_op00) = 0x0000008900000009; ++ *((unsigned long *)&__m128i_result1) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m128i_result0) = 0xffffff00ffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x371fe00000000000; ++ *((unsigned long *)&__m128i_op00) = 0x371fe00000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000ffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000ffffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbe8282a0793636d3; ++ *((unsigned long *)&__m128i_op00) = 0x793636d3793636d3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_bu (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2e2b34ca59fa4c88; ++ *((unsigned long *)&__m128i_op00) = 0x3b2c8aefd44be966; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_hu (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000100000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000080000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_hu (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7505445465593af1; ++ *((unsigned long *)&__m128i_op00) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_hu (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_hu (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00010000ffab001c; ++ *((unsigned long *)&__m128i_op00) = 0x0001ffffffadff9a; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vslti_hu (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff7300000ca00430; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001a00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_hu (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000009c83e21a; ++ *((unsigned long *)&__m128i_op00) = 0x0000000022001818; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslti_hu (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00001802041b0013; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007000000050000; ++ *((unsigned long *)&__m128i_op00) = 0x0003000000010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_op00) = 0x003dbe88077c78c1; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0100010001000100; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x975ca6046e2e4889; ++ *((unsigned long *)&__m128i_op00) = 0x1748c4f9ed1a5870; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000235600005486; ++ *((unsigned long *)&__m128i_op00) = 0x0000b31600006544; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_wu (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000007e8a60; ++ *((unsigned long *)&__m128i_op00) = 0x000000000001edde; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0aa077b7054c9554; ++ *((unsigned long *)&__m128i_op00) = 0x40c7ee1f38e4c4e8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6b75948a91407a42; ++ *((unsigned long *)&__m128i_op00) = 0x0b5471b633e54fde; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000feff23560000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fd1654860000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslti_du (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vmax-vmaxi-vmin-vm.patch
Added
@@ -0,0 +1,2578 @@ +From dd0b9d05c2e18dc8082931dbfe612bb1acf9e5e9 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 18:38:46 +0800 +Subject: PATCH 085/124 LoongArch: Add tests for SX vector + vmax/vmaxi/vmin/vmini instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vmax-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmax-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaxi-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmaxi-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmin-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmin-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmini-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmini-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vmax-1.c | 317 +++++++++++++ + .../loongarch/vector/lsx/lsx-vmax-2.c | 362 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vmaxi-1.c | 279 +++++++++++ + .../loongarch/vector/lsx/lsx-vmaxi-2.c | 223 +++++++++ + .../loongarch/vector/lsx/lsx-vmin-1.c | 434 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vmin-2.c | 344 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vmini-1.c | 314 +++++++++++++ + .../loongarch/vector/lsx/lsx-vmini-2.c | 216 +++++++++ + 8 files changed, 2489 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-2.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-1.c +new file mode 100644 +index 000000000..b0e22f955 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-1.c +@@ -0,0 +1,317 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x000000010000003f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7f007f007f007f00; ++ *((unsigned long *)&__m128i_result0) = 0x000000010000003f; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_op10) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000010000f00; ++ *((unsigned long *)&__m128i_result0) = 0x0000000010000f01; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffcfffcfffcfffd; ++ *((unsigned long *)&__m128i_op00) = 0xfffcfffdfffcfffd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff80df00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0010100000100000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100000101000; ++ *((unsigned long *)&__m128i_result1) = 0x0010100000100000; ++ *((unsigned long *)&__m128i_result0) = 0x1000100000101000; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0040000000ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x0040000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0040000000ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x0040000000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xb327b9363c992b2e; ++ *((unsigned long *)&__m128i_op10) = 0xa1e7b475d925730f; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff3c992b2e; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffff730f; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4101010141010100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000001ff; ++ *((unsigned long *)&__m128i_result1) = 0x4101010141010100; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000001ff; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op00) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000003d0000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000003d0000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0007001400000014; ++ *((unsigned long *)&__m128i_op00) = 0x0004001000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000053a; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000700140000053a; ++ *((unsigned long *)&__m128i_result0) = 0x0004001000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000034; ++ *((unsigned long *)&__m128i_op11) = 0xffff80c400000148; ++ *((unsigned long *)&__m128i_op10) = 0xffff80c1ffffe8de; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000148; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000034; ++ __m128i_out = __lsx_vmax_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff000000ff0000; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op00) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result1) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result0) = 0x000a000a000a000a; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000b3a6000067da; ++ *((unsigned long *)&__m128i_op00) = 0x00004e420000c26a; ++ *((unsigned long *)&__m128i_op11) = 0xd78cfd70b5f65d76; ++ *((unsigned long *)&__m128i_op10) = 0x5779108fdedda7e4; ++ *((unsigned long *)&__m128i_result1) = 0x0000b3a6000067da; ++ *((unsigned long *)&__m128i_result0) = 0x5779108f0000c26a; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_op00) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_op11) = 0x30eb020302101b03; ++ *((unsigned long *)&__m128i_op10) = 0x020310d0c0030220; ++ *((unsigned long *)&__m128i_result1) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_result0) = 0x020310edc003023d; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe03fe01fe01fe01; ++ *((unsigned long *)&__m128i_op00) = 0xfe3bfa3ffe3bfb21; ++ *((unsigned long *)&__m128i_op11) = 0x001d001d001d001d; ++ *((unsigned long *)&__m128i_op10) = 0x001d001d001d0000; ++ *((unsigned long *)&__m128i_result1) = 0x001d001d001d001d; ++ *((unsigned long *)&__m128i_result0) = 0x001d001d001d0000; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000155; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000155; ++ __m128i_out = __lsx_vmax_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000051649b6; ++ *((unsigned long *)&__m128i_op00) = 0xd2f005e44bb43416; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000003e0000003f; ++ *((unsigned long *)&__m128i_result1) = 0x00000000051649b6; ++ *((unsigned long *)&__m128i_result0) = 0x0000003e0000003f; ++ __m128i_out = __lsx_vmax_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128i_op10) = 0x00012c8a0000a58a; ++ *((unsigned long *)&__m128i_result1) = 0x0000ebd20000714f; ++ *((unsigned long *)&__m128i_result0) = 0x00012c8a0000a58a; ++ __m128i_out = __lsx_vmax_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-2.c +new file mode 100644 +index 000000000..51a9a92e8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmax-2.c +@@ -0,0 +1,362 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000007f0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000007f0000; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x77c0404a4000403a; ++ *((unsigned long *)&__m128i_op00) = 0x77c03fd640003fc6; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000003a0000003a; ++ *((unsigned long *)&__m128i_result1) = 0x77c0404a4000403a; ++ *((unsigned long *)&__m128i_result0) = 0x77c03fd640003fc6; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbafebb00ffd500fe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbafebb00ffd500fe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xbafebb00ffd500fe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_op00) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x5b5b5b5aa4a4a4a6; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x5b5b5b5aadadadad; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128i_op10) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128i_result1) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128i_result0) = 0xfe03fe3ffe01fa21; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000f50000007500; ++ *((unsigned long *)&__m128i_op00) = 0x00007e1600007d98; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000fe00fe; ++ *((unsigned long *)&__m128i_op10) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m128i_result1) = 0x0000f50000fe75fe; ++ *((unsigned long *)&__m128i_result0) = 0x00fe7efe00fe7dfe; ++ __m128i_out = __lsx_vmax_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c00000000; ++ *((unsigned long *)&__m128i_op11) = 0x2002040404010420; ++ *((unsigned long *)&__m128i_op10) = 0x0101010180800101; ++ *((unsigned long *)&__m128i_result1) = 0x2002040404010420; ++ *((unsigned long *)&__m128i_result0) = 0x9c9c9c9c80800101; ++ __m128i_out = __lsx_vmax_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_op11) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result1) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff0; ++ __m128i_out = __lsx_vmax_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffffdfffdf; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffdf; ++ __m128i_out = __lsx_vmax_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xf001f0010101f002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmax_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x14ccc6320076a4d2; ++ *((unsigned long *)&__m128i_op10) = 0x685670d27e00682a; ++ *((unsigned long *)&__m128i_result1) = 0x14ccc6320076a4d2; ++ *((unsigned long *)&__m128i_result0) = 0x685670d27e00682a; ++ __m128i_out = __lsx_vmax_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op11) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_op10) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_result1) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_result0) = 0x27b169bbb8145f50; ++ __m128i_out = __lsx_vmax_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff80ff0010ff06; ++ *((unsigned long *)&__m128i_op10) = 0x00007f01000eff0a; ++ *((unsigned long *)&__m128i_result1) = 0xffff80ff0010ff06; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op00) = 0x000000002bfd9461; ++ *((unsigned long *)&__m128i_op11) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3ff0000000007fff; ++ *((unsigned long *)&__m128i_result0) = 0x000000002bfd9461; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffff0000000ad3d; ++ *((unsigned long *)&__m128i_op00) = 0xfffff000fffff000; ++ *((unsigned long *)&__m128i_op11) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0xfffff00010001000; ++ *((unsigned long *)&__m128i_result0) = 0xfffff000fffff000; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000001f; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001f; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa2a2a2a3a2a2a2a3; ++ *((unsigned long *)&__m128i_op00) = 0xc605c000aedd0000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xc605c000aedd0000; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x09e8e9012fded7fd; ++ *((unsigned long *)&__m128i_op10) = 0x479f64b03373df61; ++ *((unsigned long *)&__m128i_result1) = 0x09e8e9012fded7fd; ++ *((unsigned long *)&__m128i_result0) = 0x479f64b03373df61; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_op10) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_result1) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_result0) = 0x52525252adadadad; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080700000000; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op11) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m128i_result0) = 0x0808080808080808; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vmax_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-1.c +new file mode 100644 +index 000000000..7cff1d848 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-1.c +@@ -0,0 +1,279 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0a0a0a0a0a0a0a0a; ++ *((unsigned long *)&__m128i_result0) = 0x0a0a0a0a0a0a0a0a; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result0) = 0x1000100010001000; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003be14000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000003bfb4000; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0b0b0b0b0b0b0b0b; ++ *((unsigned long *)&__m128i_result0) = 0x0b0b0b0b0b0b0b0b; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000007ffffffb; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x010101017f010101; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000007f8; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000007f8; ++ *((unsigned long *)&__m128i_result1) = 0x0b0b0b0b0b0b0b0b; ++ *((unsigned long *)&__m128i_result0) = 0x0b0b0b0b0b0b0b0b; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000c; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0606060606060606; ++ *((unsigned long *)&__m128i_result0) = 0x0606060606060606; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaxi_b (__m128i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, -11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x027c027c000027c0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x027c027c000027c0; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, -6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_op00) = 0x000001fc00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_result0) = 0x000001fc00000000; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000fff; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, -14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000007ff000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000a1ff4c; ++ *((unsigned long *)&__m128i_result1) = 0x000300037ff000ff; ++ *((unsigned long *)&__m128i_result0) = 0x0003000300a10003; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result1) = 0x000b000b000b000b; ++ *((unsigned long *)&__m128i_result0) = 0x000b000b000b000b; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result0) = 0x0004000400040004; ++ __m128i_out = __lsx_vmaxi_h (__m128i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfe07e5fefefdddfe; ++ *((unsigned long *)&__m128i_op00) = 0x00020100fedd0c00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_result0) = 0x000201000000000b; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000401000001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100000004; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001f0a; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000050000007b; ++ *((unsigned long *)&__m128i_result0) = 0x0000000500000005; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000400000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000400000004; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001fffff001fffff; ++ *((unsigned long *)&__m128i_op00) = 0x001fffff001fffff; ++ *((unsigned long *)&__m128i_result1) = 0x001fffff001fffff; ++ *((unsigned long *)&__m128i_result0) = 0x001fffff001fffff; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_result0) = 0x0000000b0000000b; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_result0) = 0x0000000e0000000e; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000900000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000900000009; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000600000006; ++ *((unsigned long *)&__m128i_result0) = 0x0000000600000006; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f80000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7f80000000000007; ++ *((unsigned long *)&__m128i_result0) = 0x0000000700000007; ++ __m128i_out = __lsx_vmaxi_w (__m128i_op0, 7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000002; ++ __m128i_out = __lsx_vmaxi_d (__m128i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000007f00; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000007f00; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000000; ++ __m128i_out = __lsx_vmaxi_d (__m128i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff489b693120950; ++ *((unsigned long *)&__m128i_op00) = 0xfffc45a851c40c18; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000a; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000a; ++ __m128i_out = __lsx_vmaxi_d (__m128i_op0, 10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmaxi_d (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x63636b6afe486741; ++ *((unsigned long *)&__m128i_op00) = 0x41f8e880ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x63636b6afe486741; ++ *((unsigned long *)&__m128i_result0) = 0x41f8e880ffffffff; ++ __m128i_out = __lsx_vmaxi_d (__m128i_op0, -2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-2.c +new file mode 100644 +index 000000000..b79af2228 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmaxi-2.c +@@ -0,0 +1,223 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000020002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000020002; ++ *((unsigned long *)&__m128i_result1) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_result0) = 0x0303030303030303; ++ __m128i_out = __lsx_vmaxi_bu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_result0) = 0x1111111111111111; ++ __m128i_out = __lsx_vmaxi_bu (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1111111111111111; ++ *((unsigned long *)&__m128i_result0) = 0x1111111111111111; ++ __m128i_out = __lsx_vmaxi_bu (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0a0a0a0a0a0a0a0a; ++ *((unsigned long *)&__m128i_result0) = 0x0a0a0a0a0a0a0a0a; ++ __m128i_out = __lsx_vmaxi_bu (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0011001100110011; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_op00) = 0x0f000d200e000c20; ++ *((unsigned long *)&__m128i_result1) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_result0) = 0x0f000d200e000c20; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_op00) = 0x000fffefffefffef; ++ *((unsigned long *)&__m128i_result1) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_result0) = 0x000fffefffefffef; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0005000500050005; ++ *((unsigned long *)&__m128i_result0) = 0x0005000500050005; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_result1) = 0x001d001d20000020; ++ *((unsigned long *)&__m128i_result0) = 0x001d001d20000020; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00003fff00010000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00123fff00120012; ++ *((unsigned long *)&__m128i_result0) = 0x0012001200120012; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001a001a001a001a; ++ *((unsigned long *)&__m128i_result0) = 0x001a001a001a001a; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001e001e001e001e; ++ *((unsigned long *)&__m128i_result0) = 0x001e001e001e001e; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001d001d001d001d; ++ *((unsigned long *)&__m128i_result0) = 0x001d001d001d001d; ++ __m128i_out = __lsx_vmaxi_hu (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000800000008; ++ __m128i_out = __lsx_vmaxi_wu (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001600000016; ++ *((unsigned long *)&__m128i_result0) = 0x0000001600000016; ++ __m128i_out = __lsx_vmaxi_wu (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmaxi_wu (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op00) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_result1) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_result0) = 0x1f5533a694f902c0; ++ __m128i_out = __lsx_vmaxi_wu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x37c0001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x37c0001000000001; ++ *((unsigned long *)&__m128i_result0) = 0x37c0001000000001; ++ __m128i_out = __lsx_vmaxi_wu (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op00) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vmaxi_wu (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0xcf00000000000000; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000011; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000001c; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001c; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000d; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000b; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128i_op00) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128i_result1) = 0x43d3e0000013e000; ++ *((unsigned long *)&__m128i_result0) = 0x43d3e0000013e000; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x000100010001007c; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000001d; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001d; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001b; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000004; ++ __m128i_out = __lsx_vmaxi_du (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-1.c +new file mode 100644 +index 000000000..b2a7a35bd +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-1.c +@@ -0,0 +1,434 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3fffff0000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ffff000000ff00; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ff91fffffff5; ++ *((unsigned long *)&__m128i_op00) = 0xffff00650001ffb0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000067400002685; ++ *((unsigned long *)&__m128i_result1) = 0x0000ff91fffffff5; ++ *((unsigned long *)&__m128i_result0) = 0xffff00650000ff85; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffcafff8ff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000a0; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000008680f1ff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xff80ffffff80ffff; ++ *((unsigned long *)&__m128i_result0) = 0xff80ffff8680f1ff; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128i_op00) = 0xff01e41ffff0e440; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffe4ffffffe4ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffe4fffff0e4ff; ++ __m128i_out = __lsx_vmin_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000a16316b0; ++ *((unsigned long *)&__m128i_op10) = 0x0000000063636363; ++ *((unsigned long *)&__m128i_result1) = 0x00000000a1630000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffc0ff81000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op10) = 0x0000000600000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffc0ff81000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000401000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00fdffffffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfe80000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfe80ffffffffff02; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfe80ffffffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x027e0000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfe80ffffffffff02; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffe0000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffe0000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op10) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_result1) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_result0) = 0xbbc8ecc5f3ced5f3; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m128i_op00) = 0xc090380000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m128i_op10) = 0xc090380000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffbfffc; ++ *((unsigned long *)&__m128i_result0) = 0xc090380000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op11) = 0x8493941335f5cc0c; ++ *((unsigned long *)&__m128i_op10) = 0x625a7312befcb21e; ++ *((unsigned long *)&__m128i_result1) = 0x8493941300000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000002befcb21e; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000078c00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000d; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op00) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result1) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result0) = 0x000a000a000a000a; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa2a2a2a3a2a2a2a3; ++ *((unsigned long *)&__m128i_op00) = 0xc605c000aedd0000; ++ *((unsigned long *)&__m128i_op11) = 0x5d5d5d5d5d5d5d5d; ++ *((unsigned long *)&__m128i_op10) = 0x5d5d5d5d5d5d0000; ++ *((unsigned long *)&__m128i_result1) = 0xa2a2a2a3a2a2a2a3; ++ *((unsigned long *)&__m128i_result0) = 0xc605c000aedd0000; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000003000000d613; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c0000000; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000200000001b; ++ *((unsigned long *)&__m128i_op00) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result0) = 0xff800000ff800000; ++ __m128i_out = __lsx_vmin_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_op11) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_result1) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000210011084; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000017f0a82; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5a5a5a5a5b5a5b5a; ++ *((unsigned long *)&__m128i_op00) = 0x5a5a5a5a5b5a5b5a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x027c027c000027c0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x027c027c000027c0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x027c027c000027c0; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000010000000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3e25c8317394dae6; ++ *((unsigned long *)&__m128i_op00) = 0xcda585aebbb2836a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xcda585aebbb2836a; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_op00) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_op11) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_op10) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_result1) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_result0) = 0x377b810912c0e000; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128i_op10) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128i_result1) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128i_result0) = 0xfcfcfcfcfcfcfcfd; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op10) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_result1) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_result0) = 0xf9796558e39953fd; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffff00ff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff00ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmin_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-2.c +new file mode 100644 +index 000000000..c90cae75e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmin-2.c +@@ -0,0 +1,344 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000300000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffe0004fffe0004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op00) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_op11) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op10) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_result1) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_result0) = 0xf9796558e39953fd; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_op00) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_op11) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_op10) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_result1) = 0xf6548a1747e59090; ++ *((unsigned long *)&__m128i_result0) = 0x27b169bbb8145f50; ++ __m128i_out = __lsx_vmin_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c63636363; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x9c9c9c9c00000000; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x2020202020207f7f; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000003f; ++ *((unsigned long *)&__m128i_op10) = 0x7f417f417f027e03; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000003f; ++ *((unsigned long *)&__m128i_result0) = 0x2020202020207e03; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00008d3200000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x09e8e9012fded7fd; ++ *((unsigned long *)&__m128i_op10) = 0x479f64b03373df61; ++ *((unsigned long *)&__m128i_result1) = 0x00008d3200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0c0b0a090b0a0908; ++ *((unsigned long *)&__m128i_op00) = 0x0a09080709080706; ++ *((unsigned long *)&__m128i_op11) = 0x0c0b0a090b0a0908; ++ *((unsigned long *)&__m128i_op10) = 0x0a09080709080706; ++ *((unsigned long *)&__m128i_result1) = 0x0c0b0a090b0a0908; ++ *((unsigned long *)&__m128i_result0) = 0x0a09080709080706; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xa87745dbd93e4ea1; ++ *((unsigned long *)&__m128i_op10) = 0xaa49601e26d39860; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op00) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op11) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_op10) = 0x2006454690d3de87; ++ *((unsigned long *)&__m128i_result1) = 0x2006454652525252; ++ *((unsigned long *)&__m128i_result0) = 0x2006454652525252; ++ __m128i_out = __lsx_vmin_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000040100; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffe000ffff2382; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000040100; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010000; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001010000; ++ *((unsigned long *)&__m128i_op11) = 0x7da9b23a624082fd; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001010000; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0505050505050505; ++ *((unsigned long *)&__m128i_op00) = 0x0000000005050000; ++ *((unsigned long *)&__m128i_op11) = 0x0028280000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0028280000282800; ++ *((unsigned long *)&__m128i_result1) = 0x0028280000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000282800; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfc01fd13fc02fe0c; ++ *((unsigned long *)&__m128i_op00) = 0xfe00fd14fe01fd16; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op10) = 0xffffff0000010000; ++ *((unsigned long *)&__m128i_result1) = 0xfc01fd1300000001; ++ *((unsigned long *)&__m128i_result0) = 0xfe00fd1400010000; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001ca02f854; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100013fa0; ++ *((unsigned long *)&__m128i_op11) = 0x2000200020002000; ++ *((unsigned long *)&__m128i_op10) = 0x2000200020002000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000120002000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100013fa0; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000005003a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op00) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op11) = 0x86dd8341b164f12b; ++ *((unsigned long *)&__m128i_op10) = 0x9611c3985b3159f5; ++ *((unsigned long *)&__m128i_result1) = 0x86dd8341b164f12b; ++ *((unsigned long *)&__m128i_result0) = 0x9611c3985b3159f5; ++ __m128i_out = __lsx_vmin_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000de0000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000006f00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001f0a; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000fea0000fffe; ++ *((unsigned long *)&__m128i_op00) = 0xff0cff78ff96ff14; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff007fff810001; ++ *((unsigned long *)&__m128i_op00) = 0x000400530050ffa6; ++ *((unsigned long *)&__m128i_op11) = 0xff7f810100001000; ++ *((unsigned long *)&__m128i_op10) = 0x001fffc0ffffe001; ++ *((unsigned long *)&__m128i_result1) = 0xff7f810100001000; ++ *((unsigned long *)&__m128i_result0) = 0x000400530050ffa6; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00007efe7f7f8000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000b81c8382; ++ *((unsigned long *)&__m128i_op10) = 0x0000000077af9450; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000077af9450; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmin_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-1.c +new file mode 100644 +index 000000000..772d040c3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-1.c +@@ -0,0 +1,314 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffefffefffffffc; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, 4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00002f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958aefff895e; ++ *((unsigned long *)&__m128i_result1) = 0xfafafafafafafafa; ++ *((unsigned long *)&__m128i_result0) = 0xfafa958aeffa89fa; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, -6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_op00) = 0x00000000adadadad; ++ *((unsigned long *)&__m128i_result1) = 0xfbfbfbfbadadadad; ++ *((unsigned long *)&__m128i_result0) = 0xfbfbfbfbadadadad; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xf1f1f1f1f1f1f1f1; ++ *((unsigned long *)&__m128i_result0) = 0xf1f1f1f1f1f1f1f1; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000f50000007500; ++ *((unsigned long *)&__m128i_op00) = 0x00007e1600007d98; ++ *((unsigned long *)&__m128i_result1) = 0x0000f50000000900; ++ *((unsigned long *)&__m128i_result0) = 0x0000090900000998; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, 9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x10f881a20ffd02b0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0xf1f181a2f1f1f1b0; ++ *((unsigned long *)&__m128i_result0) = 0xf1f1f1f1f180f1f1; ++ __m128i_out = __lsx_vmini_b (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_result0) = 0xfff6fff6fff6fff6; ++ __m128i_out = __lsx_vmini_h (__m128i_op0, -10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1716151416151413; ++ *((unsigned long *)&__m128i_op00) = 0x1514131214131211; ++ *((unsigned long *)&__m128i_result1) = 0xfff3fff3fff3fff3; ++ *((unsigned long *)&__m128i_result0) = 0xfff3fff3fff3fff3; ++ __m128i_out = __lsx_vmini_h (__m128i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_op00) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_result1) = 0xfefefefefefefefe; ++ *((unsigned long *)&__m128i_result0) = 0xfefefefefefefefe; ++ __m128i_out = __lsx_vmini_h (__m128i_op0, 2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_h (__m128i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_h (__m128i_op0, 11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_h (__m128i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff4fffffff4; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff4fffffff4; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff3fffffff3; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff3fffffff3; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, -13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_op00) = 0x000fffefffefffef; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffefffef; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, 0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op00) = 0xff01fe0400000006; ++ *((unsigned long *)&__m128i_result1) = 0x0000000500000000; ++ *((unsigned long *)&__m128i_result0) = 0xff01fe0400000005; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, 5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffafffffffa; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffafffffffa; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, -6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000d0000000d; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, 13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, 8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x345002920f3017d6; ++ *((unsigned long *)&__m128i_result1) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff7fffffff7; ++ __m128i_out = __lsx_vmini_w (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, 1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03574e3a62407e03; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff7; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000000010000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100100000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff1; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff1; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000034; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000006; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000006; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, 6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_op00) = 0x00a6ffceffb60052; ++ *((unsigned long *)&__m128i_result1) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff0; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff9; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff9; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x111110ff11111141; ++ *((unsigned long *)&__m128i_op00) = 0x1111113111111100; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x55aa55c3d5aa55c4; ++ *((unsigned long *)&__m128i_op00) = 0xaa55556fd5aaaac1; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000c; ++ *((unsigned long *)&__m128i_result0) = 0xaa55556fd5aaaac1; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, 12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff4; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffb; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffb; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_op00) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_result1) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_result0) = 0xfcfcfcdcfcfcfcdc; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, 3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001030103; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffc; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000085af0000b000; ++ *((unsigned long *)&__m128i_op00) = 0x00017ea200002000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff7; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffff4; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffff4; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, -12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128i_op00) = 0xff01e41ffff0ffff; ++ *((unsigned long *)&__m128i_result1) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128i_result0) = 0xff01e41ffff0ffff; ++ __m128i_out = __lsx_vmini_d (__m128i_op0, 14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-2.c +new file mode 100644 +index 000000000..6eaae2134 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmini-2.c +@@ -0,0 +1,216 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0001ffff0001; ++ *((unsigned long *)&__m128i_op00) = 0x0000a163000016b0; ++ *((unsigned long *)&__m128i_result1) = 0x0303000103030001; ++ *((unsigned long *)&__m128i_result0) = 0x0000030300000303; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xd8248069ffe78077; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0d0d0d0d0d0d0d0d; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7da9b23a624082fd; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0505050505050505; ++ *((unsigned long *)&__m128i_result0) = 0x0000000005050000; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op00) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_result1) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_result0) = 0x0000000e0000000e; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000001fffdfffdff; ++ *((unsigned long *)&__m128i_op00) = 0x000001fffdfffdff; ++ *((unsigned long *)&__m128i_result1) = 0x0000010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0000010101010101; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000009c007c00; ++ *((unsigned long *)&__m128i_op00) = 0x0000000071007600; ++ *((unsigned long *)&__m128i_result1) = 0x0000000009000900; ++ *((unsigned long *)&__m128i_result0) = 0x0000000009000900; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op00) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_result1) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_result0) = 0x0303030303030303; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd3220000d3f20000; ++ *((unsigned long *)&__m128i_op00) = 0x8bff0000a7b80000; ++ *((unsigned long *)&__m128i_result1) = 0x0909000009090000; ++ *((unsigned long *)&__m128i_result0) = 0x0909000009090000; ++ __m128i_out = __lsx_vmini_bu (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_hu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80000000b57ec564; ++ *((unsigned long *)&__m128i_op00) = 0x8000000083ff0be0; ++ *((unsigned long *)&__m128i_result1) = 0x0014000000140014; ++ *((unsigned long *)&__m128i_result0) = 0x0014000000140014; ++ __m128i_out = __lsx_vmini_hu (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0x0013001300130013; ++ *((unsigned long *)&__m128i_result0) = 0x0013001300130013; ++ __m128i_out = __lsx_vmini_hu (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_hu (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vmini_hu (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x02b010f881a281a2; ++ *((unsigned long *)&__m128i_op00) = 0x27b169bbb8145f50; ++ *((unsigned long *)&__m128i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200020002; ++ __m128i_out = __lsx_vmini_hu (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000040004000000; ++ *((unsigned long *)&__m128i_op00) = 0x0010002000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff0000007f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000003fc00ff00; ++ *((unsigned long *)&__m128i_op00) = 0x00000001fe01fe00; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000a; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000a; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op00) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000000b; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000014; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000d3460001518a; ++ *((unsigned long *)&__m128i_op00) = 0x000084300000e55f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000016; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff2356fe165486; ++ *((unsigned long *)&__m128i_op00) = 0x5efeb3165bd7653d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000007; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000007; ++ __m128i_out = __lsx_vmini_du (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vrotr-vrotri-vsra-.patch
Added
@@ -0,0 +1,3173 @@ +From 67c36add58d634551a200f1473be3c7368530da1 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 11:13:32 +0800 +Subject: PATCH 090/124 LoongArch: Add tests for SX vector + vrotr/vrotri/vsra/vsrai/vsran/vsrani /vsrarn/vsrarni instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vrotr.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vrotri.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsra.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrai.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsran.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrani.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrar.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrari.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrarn.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrarni.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vrotr.c | 381 +++++++++++++++++ + .../loongarch/vector/lsx/lsx-vrotri.c | 294 +++++++++++++ + .../loongarch/vector/lsx/lsx-vsra.c | 344 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vsrai.c | 258 ++++++++++++ + .../loongarch/vector/lsx/lsx-vsran.c | 290 +++++++++++++ + .../loongarch/vector/lsx/lsx-vsrani.c | 246 +++++++++++ + .../loongarch/vector/lsx/lsx-vsrar.c | 354 ++++++++++++++++ + .../loongarch/vector/lsx/lsx-vsrari.c | 265 ++++++++++++ + .../loongarch/vector/lsx/lsx-vsrarn.c | 236 +++++++++++ + .../loongarch/vector/lsx/lsx-vsrarni.c | 398 ++++++++++++++++++ + 10 files changed, 3066 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotri.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsra.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrai.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsran.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrani.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrar.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrari.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarni.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotr.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotr.c +new file mode 100644 +index 000000000..c42440cea +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotr.c +@@ -0,0 +1,381 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffffffc; ++ *((unsigned long *)&__m128i_op11) = 0x2001240128032403; ++ *((unsigned long *)&__m128i_op10) = 0x288b248c00010401; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffdfffefffff7ffe; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x5); ++ *((unsigned long *)&__m128i_op01) = 0x2700000000002727; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000002727; ++ *((unsigned long *)&__m128i_op11) = 0x697eba2bedfa9c82; ++ *((unsigned long *)&__m128i_op10) = 0xd705c77a7025c899; ++ *((unsigned long *)&__m128i_result1) = 0xc9c00000000009c9; ++ *((unsigned long *)&__m128i_result0) = 0x0013938000000000; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000000010000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100100000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x2000000020000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200200000; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_op00) = 0x203e16d116de012b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_result0) = 0x203e16d116de012b; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x9f009f009f009f00; ++ *((unsigned long *)&__m128i_result0) = 0x9f009f009f009f00; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000004fc04f81; ++ *((unsigned long *)&__m128i_op00) = 0x000000004fc04f80; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000004fc04f81; ++ *((unsigned long *)&__m128i_result0) = 0x000000004fc04f80; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff000000ff00; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_result0) = 0x0000958affff995d; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000de0000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001f0a; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x41dfffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff000200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfbffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7bffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfbffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x7bffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xf7ffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xf7feffffffffffff; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0ba00ba00ba00ba0; ++ *((unsigned long *)&__m128i_op00) = 0x0ba00ba00ba011eb; ++ *((unsigned long *)&__m128i_op11) = 0xf1819b7c0732a6b6; ++ *((unsigned long *)&__m128i_op10) = 0xffb9917a6e7fffff; ++ *((unsigned long *)&__m128i_result1) = 0x05d0ba0002e8802e; ++ *((unsigned long *)&__m128i_result0) = 0xd005e802174023d6; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op00) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000691a6c843c8fc; ++ *((unsigned long *)&__m128i_result0) = 0x000691a6918691fc; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op10) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000003f0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffc3ffff003e; ++ *((unsigned long *)&__m128i_op11) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_op10) = 0x00000000003dffc2; ++ *((unsigned long *)&__m128i_result1) = 0xc000000fc0003fff; ++ *((unsigned long *)&__m128i_result0) = 0xbffffff0ffffc00f; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_op00) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_op11) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_op10) = 0xfffdfffdfffdfffd; ++ *((unsigned long *)&__m128i_result1) = 0xffefffefffefffef; ++ *((unsigned long *)&__m128i_result0) = 0xffefffefffefffef; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001010001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001010002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010002; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080808080; ++ __m128i_out = __lsx_vrotr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x4e3e133738bb47d2; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x9c7c266e71768fa4; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001a64b345308091; ++ *((unsigned long *)&__m128i_op00) = 0x001f2f2cab1c732a; ++ *((unsigned long *)&__m128i_op11) = 0x0000014414104505; ++ *((unsigned long *)&__m128i_op10) = 0x1011050040004101; ++ *((unsigned long *)&__m128i_result1) = 0x001a323b5430048c; ++ *((unsigned long *)&__m128i_result0) = 0x008f792cab1cb915; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000001e03; ++ *((unsigned long *)&__m128i_op11) = 0x001a64b345308091; ++ *((unsigned long *)&__m128i_op10) = 0x001f2f2cab1c732a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000780c00000; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00020000ffff0001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000b000b000b000b; ++ *((unsigned long *)&__m128i_op00) = 0x000b000b000b000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000b000b000b000b; ++ *((unsigned long *)&__m128i_result0) = 0x000b000b000b000b; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0005840100000005; ++ *((unsigned long *)&__m128i_op00) = 0x0005847b00000000; ++ *((unsigned long *)&__m128i_op11) = 0x636363633f3e47c1; ++ *((unsigned long *)&__m128i_op10) = 0x41f8e080f1ef4eaa; ++ *((unsigned long *)&__m128i_result1) = 0xa000308000008002; ++ *((unsigned long *)&__m128i_result0) = 0x0500847b00000000; ++ __m128i_out = __lsx_vrotr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotri.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotri.c +new file mode 100644 +index 000000000..4ae4dbf8b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vrotri.c +@@ -0,0 +1,294 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_result1) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000000020000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0d1bffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xd915e98e2d8df4d1; ++ *((unsigned long *)&__m128i_result1) = 0xd0b1ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x9d519ee8d2d84f1d; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_op00) = 0x203e16d116de012b; ++ *((unsigned long *)&__m128i_result1) = 0x887c8beb969e00f2; ++ *((unsigned long *)&__m128i_result0) = 0x101f8b680b6f8095; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0800000008000000; ++ *((unsigned long *)&__m128i_result0) = 0x0800000008000000; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000c00; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffff01; ++ *((unsigned long *)&__m128i_op00) = 0xffffeff400000df4; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffff03fe; ++ *((unsigned long *)&__m128i_result0) = 0xffffe9df0000e81b; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0x000000de00003e14; ++ *((unsigned long *)&__m128i_result0) = 0x00012b15ffff32ba; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x80001b155b4b0000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x80001b155b4b0000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffefffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffefffff; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111113111111141; ++ *((unsigned long *)&__m128i_op00) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_result1) = 0x1111311111114111; ++ *((unsigned long *)&__m128i_result0) = 0x1111311111112111; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x35); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0008000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff800000003; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000003f0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffc3ffff003e; ++ *((unsigned long *)&__m128i_result1) = 0x00001f80007fff80; ++ *((unsigned long *)&__m128i_result0) = 0xffffe1ffff801f7f; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfff0000ffff0000f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ff02d060; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff02d060; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x27b9331b8e77ead9; ++ *((unsigned long *)&__m128i_op00) = 0x58d6bf1867ace738; ++ *((unsigned long *)&__m128i_result1) = 0xe4cc6c9edfab6639; ++ *((unsigned long *)&__m128i_result0) = 0x5afc6163b39ce19e; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_w (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vrotri_d (__m128i_op0, 0x21); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vrotri_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsra.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsra.c +new file mode 100644 +index 000000000..fd7c22a82 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsra.c +@@ -0,0 +1,344 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op00) = 0x1e801ffc7fc00000; ++ *((unsigned long *)&__m128i_op11) = 0x00ed0008005e00a2; ++ *((unsigned long *)&__m128i_op10) = 0x007a007600150077; ++ *((unsigned long *)&__m128i_result1) = 0x0003000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x0007007f03fe0000; ++ __m128i_out = __lsx_vsra_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffe001ffffe001; ++ *((unsigned long *)&__m128i_op10) = 0xffffe001ffffe001; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fc000003fc00000; ++ *((unsigned long *)&__m128i_op00) = 0x3fc000003fc00000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3fc000003fc00000; ++ *((unsigned long *)&__m128i_result0) = 0x3fc000003fc00000; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00003ff000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000fffc00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x85bd6b0e94d89998; ++ *((unsigned long *)&__m128i_op00) = 0xd83c8081ffff8080; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x85bd6b0e94d89998; ++ *((unsigned long *)&__m128i_result0) = 0xd83c8081ffff8080; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe0d56a9774f3ea31; ++ *((unsigned long *)&__m128i_op00) = 0xbddaa86803e33c2a; ++ *((unsigned long *)&__m128i_op11) = 0xe0d56a9774f3ea31; ++ *((unsigned long *)&__m128i_op10) = 0xbddaa86803e33c2a; ++ *((unsigned long *)&__m128i_result1) = 0xff0600d50e9ef518; ++ *((unsigned long *)&__m128i_result0) = 0xffefffa8007c000f; ++ __m128i_out = __lsx_vsra_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xaaaaffebcfb748e0; ++ *((unsigned long *)&__m128i_op10) = 0xfd293eab528e7ebe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffefff6fff80002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xe0404041e0404041; ++ *((unsigned long *)&__m128i_op10) = 0x803f800080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000700ff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000040004000000; ++ *((unsigned long *)&__m128i_op10) = 0x0010002000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000700ff00000000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000820000ff81; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff810000ff81; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000820000ff81; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff810000ff81; ++ __m128i_out = __lsx_vsra_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x800080007f008000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0a0aa9890a0ac5f3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffff000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x01203f1e3d1c3b1a; ++ *((unsigned long *)&__m128i_op00) = 0x3918371635143312; ++ *((unsigned long *)&__m128i_op11) = 0x21201f1e1d001b25; ++ *((unsigned long *)&__m128i_op10) = 0x191817161514131d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001e8e1d8; ++ *((unsigned long *)&__m128i_result0) = 0x000000e400000001; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000080008; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000fffe01fd02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000040002; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000c0c00000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffac0a000000; ++ *((unsigned long *)&__m128i_op11) = 0x801d5de0000559e0; ++ *((unsigned long *)&__m128i_op10) = 0x77eb86788eebafe1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffac00000000; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfcfcfcfcfcfcfcfd; ++ *((unsigned long *)&__m128i_op10) = 0xfcfcfcfcfcfc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op00) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_result0) = 0x5252525252525252; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x2e2b34ca59fa4c88; ++ *((unsigned long *)&__m128i_op10) = 0x3b2c8aefd44be966; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0802080408060803; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x00001fffe0001fff; ++ __m128i_out = __lsx_vsra_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_result0) = 0x7f8000007f800000; ++ __m128i_out = __lsx_vsra_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000047fe2f0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000047fe2f0; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010012; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fec20704; ++ *((unsigned long *)&__m128i_result1) = 0x00000000043fe2fc; ++ *((unsigned long *)&__m128i_result0) = 0x00000000001fffff; ++ __m128i_out = __lsx_vsra_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrai.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrai.c +new file mode 100644 +index 000000000..2ca4f0b7a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrai.c +@@ -0,0 +1,258 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x21); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001ffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ca354688; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000040400000383; ++ *((unsigned long *)&__m128i_op00) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000007; ++ *((unsigned long *)&__m128i_result0) = 0xffffffc0ffff003f; ++ __m128i_out = __lsx_vsrai_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf6e91c0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x51cfd7c000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffd000700000000; ++ *((unsigned long *)&__m128i_result0) = 0x0014fff500000000; ++ __m128i_out = __lsx_vsrai_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3c600000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0f180000ffe00000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21f32eaf5b7a02c8; ++ *((unsigned long *)&__m128i_op00) = 0x407c2ca32cbd0357; ++ *((unsigned long *)&__m128i_result1) = 0x10f917d72d3d01e4; ++ *((unsigned long *)&__m128i_result0) = 0x203e16d116de012b; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_w (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x01ff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x01ff000000000000; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1268f057137a0267; ++ *((unsigned long *)&__m128i_op00) = 0x0048137ef886fae0; ++ *((unsigned long *)&__m128i_result1) = 0x000000490000004d; ++ *((unsigned long *)&__m128i_result0) = 0x00000001ffffffe2; ++ __m128i_out = __lsx_vsrai_w (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffffff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00ffffff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ffffffffff; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfe80ffffffffff02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffe80; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x30); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001800000039; ++ *((unsigned long *)&__m128i_op00) = 0x00000049ffffffaa; ++ *((unsigned long *)&__m128i_result1) = 0x000000060000000e; ++ *((unsigned long *)&__m128i_result0) = 0x000000127fffffea; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0aa077b7054c9554; ++ *((unsigned long *)&__m128i_op00) = 0x40c7ee1f38e4c4e8; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000ffff; ++ __m128i_out = __lsx_vsrai_h (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_w (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x3fff3fff3fff3fff; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002ebf; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x31); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x31); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_w (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000190; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010058; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000100010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x00f0001000000010; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x00f0001000000010; ++ __m128i_out = __lsx_vsrai_h (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrai_d (__m128i_op0, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vsrai_h (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsran.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsran.c +new file mode 100644 +index 000000000..4e7c7ab7e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsran.c +@@ -0,0 +1,290 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fffe0001fffe; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0303020102020001; ++ *((unsigned long *)&__m128i_op00) = 0x0002000000000201; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xd82480697f678077; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0301020100000004; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff02; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3c5fffffff7fffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffefffeff00feff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000e0180000e810; ++ *((unsigned long *)&__m128i_op00) = 0x0000f0080000f800; ++ *((unsigned long *)&__m128i_op11) = 0x0000e0180000e810; ++ *((unsigned long *)&__m128i_op10) = 0x0000f0080000f800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000f0f800; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff00000000; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100089bde; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000104000800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x80044def00000001; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x00000100f8100002; ++ *((unsigned long *)&__m128i_op10) = 0xfff0ff8006f0f950; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000001f0a; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff7a53; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000bf; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000002bb; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000021e79364; ++ *((unsigned long *)&__m128i_op00) = 0x0000718ea657431b; ++ *((unsigned long *)&__m128i_op11) = 0xfefffffffeffda6f; ++ *((unsigned long *)&__m128i_op10) = 0xfefffffffeffe3d7; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff0000ff86; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0101fe870101fe87; ++ *((unsigned long *)&__m128i_op10) = 0x0101fe8700000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op00) = 0x353c8cc4b1ec5b09; ++ *((unsigned long *)&__m128i_op11) = 0x002affd600000001; ++ *((unsigned long *)&__m128i_op10) = 0xcbc2723a4f12a5f8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8080808000000035; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000100; ++ *((unsigned long *)&__m128i_op00) = 0x00000001000000ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00ff80ff00ff80ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000000; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff000ff6220c0c1; ++ *((unsigned long *)&__m128i_op00) = 0xffe8081000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ff000ff6220c0c1; ++ *((unsigned long *)&__m128i_op10) = 0xffe8081000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xb110606000000000; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0037ffd40083ffe5; ++ *((unsigned long *)&__m128i_op00) = 0x001e0052001ffff9; ++ *((unsigned long *)&__m128i_op11) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_op10) = 0x001effae001effae; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00df020f0078007f; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80ffa2fff0ff74; ++ *((unsigned long *)&__m128i_op00) = 0xff76ffd8ffe6ffaa; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffc105d1aa; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffbc19ecca; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffe03ff63ff9bf; ++ __m128i_out = __lsx_vsran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x06d9090909090909; ++ *((unsigned long *)&__m128i_op11) = 0x0039d21e3229d4e8; ++ *((unsigned long *)&__m128i_op10) = 0x6d339b4f3b439885; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000db24848; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfe3bfb01fe3bfe01; ++ *((unsigned long *)&__m128i_op10) = 0xfe03fe3ffe01fa21; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vsran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrani.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrani.c +new file mode 100644 +index 000000000..92988035d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrani.c +@@ -0,0 +1,246 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000b0000000b; ++ *((unsigned long *)&__m128i_op00) = 0x000201000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0005000501800005; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x438ff81ff81ff820; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x03ff03ff03ff03ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000043; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vsrani_d_q (__m128i_op0, __m128i_op1, 0x78); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000002020202; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_d_q (__m128i_op0, __m128i_op1, 0x5b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000009; ++ *((unsigned long *)&__m128i_op11) = 0x697eba2bedfa9c82; ++ *((unsigned long *)&__m128i_op10) = 0xd705c77a7025c899; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result0) = 0x03fdfffcfefe03fe; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0100000001000100; ++ *((unsigned long *)&__m128i_op00) = 0x0100010000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00ffffff00ff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000010001000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff00ff00ffffff; ++ __m128i_out = __lsx_vsrani_h_w (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x40f0001000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1e0200001e020000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_op10) = 0x0800080008000800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0040004000400040; ++ __m128i_out = __lsx_vsrani_w_d (__m128i_op0, __m128i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000040000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_d_q (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001ffce00016fb41; ++ *((unsigned long *)&__m128i_op00) = 0x57cb857100001a46; ++ *((unsigned long *)&__m128i_op11) = 0xfbffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x7bffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000150000; ++ *((unsigned long *)&__m128i_result0) = 0xfffeffff001effff; ++ __m128i_out = __lsx_vsrani_h_w (__m128i_op0, __m128i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_wu (__m128i_op0, 0x1); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op10) = 0x2020202020207fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x01010101010101ff; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff082f000000000; ++ *((unsigned long *)&__m128i_op10) = 0x003f000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff000000000000; ++ __m128i_out = __lsx_vsrani_h_w (__m128i_op0, __m128i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_h_w (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00005dcbe7e830c0; ++ *((unsigned long *)&__m128i_op00) = 0x03f21e0114bf19da; ++ *((unsigned long *)&__m128i_op11) = 0x000003f200001e01; ++ *((unsigned long *)&__m128i_op10) = 0x000014bf000019da; ++ *((unsigned long *)&__m128i_result1) = 0x0005fe0300010101; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100010001; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op11) = 0x62cbf96e4acfaf40; ++ *((unsigned long *)&__m128i_op10) = 0xf0bc9a5278285a4a; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x62cbf96e4acfaf40; ++ __m128i_out = __lsx_vsrani_d_q (__m128i_op0, __m128i_op1, 0x40); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op00) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1f54e0ab00000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffb6d01f5f94f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001f50000; ++ __m128i_out = __lsx_vsrani_h_w (__m128i_op0, __m128i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_w_d (__m128i_op0, __m128i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x808080e280808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080636380806363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8080808080638063; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000001d; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000001d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_d_q (__m128i_op0, __m128i_op1, 0x63); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0f07697100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000076971000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_w_d (__m128i_op0, __m128i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000003020302; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffff81; ++ *((unsigned long *)&__m128i_result1) = 0x00000c0c00000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffe; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_d_q (__m128i_op0, __m128i_op1, 0x58); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vsrani_w_d (__m128i_op0, __m128i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrani_b_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5847b72626ce61ef; ++ *((unsigned long *)&__m128i_op00) = 0x110053f401e7cced; ++ *((unsigned long *)&__m128i_op11) = 0x5847b72626ce61ef; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0005847b00011005; ++ *((unsigned long *)&__m128i_result0) = 0x0005847b00000000; ++ __m128i_out = __lsx_vsrani_w_d (__m128i_op0, __m128i_op1, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrar.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrar.c +new file mode 100644 +index 000000000..6a842d9ce +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrar.c +@@ -0,0 +1,354 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff02ff1bff02ff23; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffff02fff4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op00) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_result0) = 0x0000001300000013; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_result0) = 0xff00ff00ff00ff00; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000400000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffefefe6a; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c2bac2c2; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffff0000000002; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c2bac2c2; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x000000010000003f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x000000010000003f; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op11) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x4f804f804f804f80; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80010001b57fc565; ++ *((unsigned long *)&__m128i_op00) = 0x8001000184000be0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x80010001b57fc565; ++ *((unsigned long *)&__m128i_result0) = 0x8001000184000be0; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0bd80bd80bdfffff; ++ *((unsigned long *)&__m128i_op10) = 0x0bd80bd80bd80000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000006f00001f0a; ++ *((unsigned long *)&__m128i_result0) = 0x0000958affff995d; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000080000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc0fffff000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000bf; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000002bb; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xc0fffff000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_op00) = 0xffff6080ffff4417; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_result0) = 0xffff6080ffff4417; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3fbf3fbf00007fff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000003a0000003a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000003a0000003a; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0086000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0082000000000007; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0086000000040000; ++ *((unsigned long *)&__m128i_result0) = 0x0082000000000007; ++ __m128i_out = __lsx_vsrar_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x467f6080467d607f; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0037ffc8d7ff2800; ++ *((unsigned long *)&__m128i_op00) = 0xff00000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op10) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result1) = 0x001bffe4ebff9400; ++ *((unsigned long *)&__m128i_result0) = 0xff80000000000000; ++ __m128i_out = __lsx_vsrar_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2a29282726252423; ++ *((unsigned long *)&__m128i_op00) = 0x2221201f1e1d1c1b; ++ *((unsigned long *)&__m128i_op11) = 0x2a29282726252423; ++ *((unsigned long *)&__m128i_op10) = 0x2221201f1e1d1c1b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000005452505; ++ *((unsigned long *)&__m128i_result0) = 0x00000004442403e4; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0100010001000100; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000002; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x00000c0c00000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffc00000ff800000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffe4866c86; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffe4866c86; ++ *((unsigned long *)&__m128i_result1) = 0x0001000002000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000002000000; ++ __m128i_out = __lsx_vsrar_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x1748c4f9ed1a5870; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1748c4f9ed1a5870; ++ __m128i_out = __lsx_vsrar_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x680485c8b304b019; ++ *((unsigned long *)&__m128i_op00) = 0xc89d7f0ff90da019; ++ *((unsigned long *)&__m128i_op11) = 0x680485c8b304b019; ++ *((unsigned long *)&__m128i_op10) = 0xc89d7f0ff90da019; ++ *((unsigned long *)&__m128i_result1) = 0x00680486ffffffda; ++ *((unsigned long *)&__m128i_result0) = 0xffff913bfffffffd; ++ __m128i_out = __lsx_vsrar_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op10) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrar_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrari.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrari.c +new file mode 100644 +index 000000000..2a353d65a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrari.c +@@ -0,0 +1,265 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000cb4a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000f909; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_d (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf4b6f3f52f4ef4a8; ++ *((unsigned long *)&__m128i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfff5fff4002ffff5; ++ __m128i_out = __lsx_vsrari_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffc0ff81000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff0ffe04000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000000f3; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000f3; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000958affff995d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000fdfc0000fd03; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000017161515; ++ *((unsigned long *)&__m128i_op00) = 0x0000000095141311; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_d (__m128i_op0, 0x34); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e19181716; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000109000000c9; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x77c0404a4000403a; ++ *((unsigned long *)&__m128i_op00) = 0x77c03fd640003fc6; ++ *((unsigned long *)&__m128i_result1) = 0x00f0008100800080; ++ *((unsigned long *)&__m128i_result0) = 0x00f0008000800080; ++ __m128i_out = __lsx_vsrari_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000006c80031; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_d (__m128i_op0, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000a6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001200100012001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000080000000800; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_d (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000404040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000020; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb020302101b03; ++ *((unsigned long *)&__m128i_op00) = 0x020310d0c0030220; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_op00) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_result1) = 0x0001340134013401; ++ *((unsigned long *)&__m128i_result0) = 0x0001340134013401; ++ __m128i_out = __lsx_vsrari_d (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_w (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrari_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarn.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarn.c +new file mode 100644 +index 000000000..60d474203 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarn.c +@@ -0,0 +1,236 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_op00) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffefffffffef; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffff1; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffefff6fff80002; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff000000fefb0000; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000200; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000c2f90000bafa; ++ *((unsigned long *)&__m128i_op00) = 0x8000c2fa8000c2fa; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xc2f9bafac2fac2fa; ++ __m128i_out = __lsx_vsrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000004; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff0204; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x01203f1e3d1c3b1a; ++ *((unsigned long *)&__m128i_op00) = 0x3918371635143312; ++ *((unsigned long *)&__m128i_op11) = 0x000000000001d5d4; ++ *((unsigned long *)&__m128i_op10) = 0x000000150d707009; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x03f1e3d28b1a8a1a; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffefffefffeffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffefffefffeffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff7f810100001000; ++ *((unsigned long *)&__m128i_op00) = 0x001fffc0ffffe001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000002259662; ++ *((unsigned long *)&__m128i_op10) = 0xc4dbe60354005d25; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f01000000f8ff00; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff6ff4ffff8db8; ++ *((unsigned long *)&__m128i_op00) = 0xffffbaf4ffffb805; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x9c7c266e71768fa4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfff4ffb800ff0080; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op00) = 0x0000000044470000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00004dce00004700; ++ __m128i_out = __lsx_vsrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0b4c600000000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x08080807f5f5f5f8; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0202f5f80000ff00; ++ __m128i_out = __lsx_vsrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0d060d060d060d06; ++ *((unsigned long *)&__m128i_op00) = 0x0d060d060d060d06; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0d060d060d060d06; ++ __m128i_out = __lsx_vsrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffee; ++ *((unsigned long *)&__m128i_op00) = 0x00000000011ff040; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff01fe03ff01fe03; ++ *((unsigned long *)&__m128i_op00) = 0xff01fe03ff01fe03; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff01fe03ff01fe03; ++ __m128i_out = __lsx_vsrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarni.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarni.c +new file mode 100644 +index 000000000..3aa23bdc8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrarni.c +@@ -0,0 +1,398 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff020000fff4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff020000fff4; ++ *((unsigned long *)&__m128i_op11) = 0x7fc0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1e801ffc00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000080007f80800; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x4b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000001e5; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x5000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xff80000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xff8000002f4ef4a8; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000f4a8; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00100184017e0032; ++ *((unsigned long *)&__m128i_op00) = 0x0086018c01360164; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffffff33c4b1e67; ++ *((unsigned long *)&__m128i_result1) = 0x0000800c0004300c; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op00) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op11) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_op10) = 0x0000000e0000000e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_b_h (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x66); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4101010141010100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000001ff; ++ *((unsigned long *)&__m128i_result1) = 0x0020808100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x29); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x64); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_op10) = 0x028c026bfff027af; ++ *((unsigned long *)&__m128i_result1) = 0x00000003fc03fc00; ++ *((unsigned long *)&__m128i_result0) = 0xffffc00a3009b000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ffa7f8ff81; ++ *((unsigned long *)&__m128i_op00) = 0x0000003f0080ffc0; ++ *((unsigned long *)&__m128i_op11) = 0x000000007fff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000a7f87fffff81; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffd400000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000004000000040; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x003f800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000080003f80ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_result0) = 0x000001fc00000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff80010001; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff80010001; ++ *((unsigned long *)&__m128i_op11) = 0x0bd80bd80bdfffff; ++ *((unsigned long *)&__m128i_op10) = 0x0bd80bd80bd80000; ++ *((unsigned long *)&__m128i_result1) = 0x1ffffffff8001000; ++ *((unsigned long *)&__m128i_result0) = 0xf0bd80bd80bd8000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x24); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xecec006c00000000; ++ *((unsigned long *)&__m128i_op00) = 0xecec006c00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff007f00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff007f00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_b_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000001ff85ffdc0; ++ *((unsigned long *)&__m128i_op10) = 0x0000332ae5d97330; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1ff85ffe2ae5d973; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000043c5ea7b6; ++ *((unsigned long *)&__m128i_op00) = 0x00000008fc4ef7b4; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000fea0000fffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_b_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x48); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000dfa6e0c6; ++ *((unsigned long *)&__m128i_op00) = 0x00000000d46cdc13; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x64); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x09e8e9012fded7fd; ++ *((unsigned long *)&__m128i_op00) = 0x479f64b03373df61; ++ *((unsigned long *)&__m128i_op11) = 0x04c0044a0400043a; ++ *((unsigned long *)&__m128i_op10) = 0x04c004d6040004c6; ++ *((unsigned long *)&__m128i_result1) = 0x1d20db00ec967bec; ++ *((unsigned long *)&__m128i_result0) = 0x00890087009b0099; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_op10) = 0x0000080800000808; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8080000180800001; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000003e; ++ *((unsigned long *)&__m128i_op11) = 0x00fe00fe000200fe; ++ *((unsigned long *)&__m128i_op10) = 0x00fe00fe000200fe; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000003e; ++ *((unsigned long *)&__m128i_result0) = 0xfefe02fefefe02fe; ++ __m128i_out = __lsx_vsrarni_b_h (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_b_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_op00) = 0x1000000010000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op10) = 0x0103000201030002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x26); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_op10) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffc000400000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00003fff00010000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x6d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff010000ff01; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op00) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op11) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op10) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_result1) = 0xf359f359f359f359; ++ *((unsigned long *)&__m128i_result0) = 0xf359f359f359f359; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_b_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x01533b5e7489ae24; ++ *((unsigned long *)&__m128i_op00) = 0xffffab7e71e33848; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xce9135c49ffff570; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_d_q (__m128i_op0, __m128i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000807bf0a1f80; ++ *((unsigned long *)&__m128i_op00) = 0x00000800ecedee68; ++ *((unsigned long *)&__m128i_op11) = 0x0005840100000005; ++ *((unsigned long *)&__m128i_op10) = 0x0005847b00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001f0a20001cedf; ++ *((unsigned long *)&__m128i_result0) = 0x0058000000580000; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffb1fb1000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf2c97aaa7d8fa270; ++ *((unsigned long *)&__m128i_op10) = 0x0b73e427f7cfcb88; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrarni_w_d (__m128i_op0, __m128i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0a545374471b7070; ++ *((unsigned long *)&__m128i_op00) = 0x274f4f0648145f50; ++ *((unsigned long *)&__m128i_op11) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op10) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result1) = 0xa8a736e19e9e28bf; ++ *((unsigned long *)&__m128i_result0) = 0x9e9f9e9f9e9f9e9f; ++ __m128i_out = __lsx_vsrarni_h_w (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vsll-vslli-vsrl-vs.patch
Added
@@ -0,0 +1,4023 @@ +From 64d3c9507fdf2829659affdb7d0490e7b2888787 Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 10:55:35 +0800 +Subject: PATCH 089/124 LoongArch: Add tests for SX vector + vsll/vslli/vsrl/vsrli/vsrln/vsrlni/vsrlr /vsrlri/vslrlrn/vsrlrni + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vsll.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vslli.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsllwil-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsllwil-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrl.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrli.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrln.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrlni.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrlr.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrlri.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrlrn.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vsrlrni.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vsll.c | 254 +++++++ + .../loongarch/vector/lsx/lsx-vslli.c | 293 ++++++++ + .../loongarch/vector/lsx/lsx-vsllwil-1.c | 244 +++++++ + .../loongarch/vector/lsx/lsx-vsllwil-2.c | 189 +++++ + .../loongarch/vector/lsx/lsx-vsrl.c | 389 ++++++++++ + .../loongarch/vector/lsx/lsx-vsrli.c | 328 +++++++++ + .../loongarch/vector/lsx/lsx-vsrln.c | 335 +++++++++ + .../loongarch/vector/lsx/lsx-vsrlni.c | 281 +++++++ + .../loongarch/vector/lsx/lsx-vsrlr.c | 434 +++++++++++ + .../loongarch/vector/lsx/lsx-vsrlri.c | 300 ++++++++ + .../loongarch/vector/lsx/lsx-vsrlrn.c | 164 +++++ + .../loongarch/vector/lsx/lsx-vsrlrni.c | 686 ++++++++++++++++++ + 12 files changed, 3897 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsll.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslli.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrl.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrli.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrln.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlni.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlr.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlri.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrni.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsll.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsll.c +new file mode 100644 +index 000000000..7b8ad7d5a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsll.c +@@ -0,0 +1,254 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op00) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_op11) = 0x1dcc4255c9d85c05; ++ *((unsigned long *)&__m128i_op10) = 0x3ab7a3fc47a5c31a; ++ *((unsigned long *)&__m128i_result1) = 0xb9884ab93b0b80a0; ++ *((unsigned long *)&__m128i_result0) = 0xf11e970c68000000; ++ __m128i_out = __lsx_vsll_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op00) = 0x0100000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_result0) = 0x0100000100010001; ++ __m128i_out = __lsx_vsll_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00307028003f80b0; ++ *((unsigned long *)&__m128i_op00) = 0x0040007fff800000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffc0ffffff81; ++ *((unsigned long *)&__m128i_op10) = 0xffff008000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0060e050007f0160; ++ *((unsigned long *)&__m128i_result0) = 0x0040007fff800000; ++ __m128i_out = __lsx_vsll_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000401000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000401000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3fffffff80000000; ++ *((unsigned long *)&__m128i_op00) = 0x00003ffd000a4000; ++ *((unsigned long *)&__m128i_op11) = 0xfffcffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000fffd000a0000; ++ *((unsigned long *)&__m128i_result1) = 0xf000800080000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000a00028004000; ++ __m128i_out = __lsx_vsll_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6b9fe3649c9d6363; ++ *((unsigned long *)&__m128i_op00) = 0x6363bc9e8b696363; ++ *((unsigned long *)&__m128i_op11) = 0x6b9fe3649c9d6363; ++ *((unsigned long *)&__m128i_op10) = 0x6363bc9e8b696363; ++ *((unsigned long *)&__m128i_result1) = 0xb9fe3640e4eb1b18; ++ *((unsigned long *)&__m128i_result0) = 0x800000005b4b1b18; ++ __m128i_out = __lsx_vsll_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x80001b155b4b0000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00006c82; ++ *((unsigned long *)&__m128i_op10) = 0x00009b140000917b; ++ *((unsigned long *)&__m128i_result1) = 0x80000000fffffffc; ++ *((unsigned long *)&__m128i_result0) = 0xb150000000000000; ++ __m128i_out = __lsx_vsll_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff7e00000081; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000008000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsll_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x03f1e3d28b1a8a1a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x03f1e3d28b1a8a1a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x18e2184858682868; ++ __m128i_out = __lsx_vsll_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ff02d060; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ff02d060; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff02d06000000000; ++ __m128i_out = __lsx_vsll_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100010001; ++ __m128i_out = __lsx_vsll_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vsll_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vsll_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000200000001c; ++ *((unsigned long *)&__m128i_op00) = 0x000000200000001c; ++ *((unsigned long *)&__m128i_op11) = 0x000000200000001c; ++ *((unsigned long *)&__m128i_op10) = 0x000000200000001c; ++ *((unsigned long *)&__m128i_result1) = 0x00000020000000c0; ++ *((unsigned long *)&__m128i_result0) = 0x00000020000000c0; ++ __m128i_out = __lsx_vsll_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsll_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslli.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslli.c +new file mode 100644 +index 000000000..7a77e80c0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vslli.c +@@ -0,0 +1,293 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x35); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xaaaaffebcfb748e0; ++ *((unsigned long *)&__m128i_op00) = 0xfd293eab528e7ebe; ++ *((unsigned long *)&__m128i_result1) = 0xf6e91c0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x51cfd7c000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffff0ffe04000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_result0) = 0xfffcfffcfffcfffc; ++ __m128i_out = __lsx_vslli_h (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc39fffff007fffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000fe00fd; ++ *((unsigned long *)&__m128i_result1) = 0x0e7ffffc01fffffc; ++ *((unsigned long *)&__m128i_result0) = 0x0000000003f803f4; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vslli_h (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000000000; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000040; ++ __m128i_out = __lsx_vslli_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff00ffff00ff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result1) = 0xfcfcfc00fcfc00fc; ++ *((unsigned long *)&__m128i_result0) = 0xfcfcfcfcfcfcfc00; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000060; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x38); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000f00f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000f00f; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000d46cdc13; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000060000000; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x61608654a2d4f6da; ++ *((unsigned long *)&__m128i_result1) = 0xfee0000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xc2c00ca844a8ecb4; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_h (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_op00) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result1) = 0x0100000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0100000000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x36); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op00) = 0x00ff010300ff0103; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_result0) = 0xf0003000f0003000; ++ __m128i_out = __lsx_vslli_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff800fff01; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff001ffe02; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd78cfd70b5f65d76; ++ *((unsigned long *)&__m128i_op00) = 0x5779108fdedda7e4; ++ *((unsigned long *)&__m128i_result1) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_result0) = 0xc8847ef6ed3f2000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m128i_op00) = 0xfffffff7fffffff7; ++ *((unsigned long *)&__m128i_result1) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_result0) = 0xfcfcfcdcfcfcfcdc; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result1) = 0xc0c0c0c0c0c0c0c0; ++ *((unsigned long *)&__m128i_result0) = 0xc0c0c0c0c0c0c0c0; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe2560afe9c001a18; ++ *((unsigned long *)&__m128i_op00) = 0xe2560afe9c001a18; ++ *((unsigned long *)&__m128i_result1) = 0x89582bf870006860; ++ *((unsigned long *)&__m128i_result0) = 0x89582bf870006860; ++ __m128i_out = __lsx_vslli_w (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x841f000fc28f801f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x107c003c083c007c; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff9727ffff9727; ++ *((unsigned long *)&__m128i_op00) = 0xfffffe79ffffba5f; ++ *((unsigned long *)&__m128i_result1) = 0xffff972700000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffba5f00000000; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x20); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x101b0330eb022002; ++ *((unsigned long *)&__m128i_op00) = 0x030220020310edc0; ++ *((unsigned long *)&__m128i_result1) = 0x0080800080000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080008000; ++ __m128i_out = __lsx_vslli_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x317fce80317fce80; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xf0000000f0000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vslli_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0177fff0fffffff0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000011ff8bc; ++ *((unsigned long *)&__m128i_result1) = 0x05dfffc3ffffffc0; ++ *((unsigned long *)&__m128i_result0) = 0x00000000047fe2f0; ++ __m128i_out = __lsx_vslli_d (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-1.c +new file mode 100644 +index 000000000..796e88cad +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-1.c +@@ -0,0 +1,244 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_op00) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000002000000020; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000e0000000e0; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000fc00; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000fc00; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0xffeb48e03eab7ebe; ++ *((unsigned long *)&__m128i_result1) = 0xffc0fac01200f800; ++ *((unsigned long *)&__m128i_result0) = 0x0f80eac01f80ef80; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000e7e20468; ++ *((unsigned long *)&__m128i_op00) = 0xc2fac2fa53e7db29; ++ *((unsigned long *)&__m128i_result1) = 0xff84fff4ff84fff4; ++ *((unsigned long *)&__m128i_result0) = 0x00a6ffceffb60052; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x002e0059003b0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000005c000000b2; ++ *((unsigned long *)&__m128i_result0) = 0x0000007600000000; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x2e34594c3b000000; ++ *((unsigned long *)&__m128i_result1) = 0x017001a002c80260; ++ *((unsigned long *)&__m128i_result0) = 0x01d8000000000000; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_op00) = 0x4f4f4f4f4f4f4f4f; ++ *((unsigned long *)&__m128i_result1) = 0x09e009e009e009e0; ++ *((unsigned long *)&__m128i_result0) = 0x09e009e009e009e0; ++ __m128i_out = __lsx_vsllwil_h_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000040000000400; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000005050000; ++ *((unsigned long *)&__m128i_op00) = 0x0505000005050505; ++ *((unsigned long *)&__m128i_result1) = 0x0028280000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0028280000282800; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffff800; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0xffc0000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffc0000000000000; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffff00ffffff00; ++ *((unsigned long *)&__m128i_result0) = 0xffffff00ffffff00; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf10cf508f904fd01; ++ *((unsigned long *)&__m128i_op00) = 0xf10cf508f904fd01; ++ *((unsigned long *)&__m128i_result1) = 0xffffe218ffffea10; ++ *((unsigned long *)&__m128i_result0) = 0xfffff208fffffa02; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21201f1e1d001b1a; ++ *((unsigned long *)&__m128i_op00) = 0x1918171615141312; ++ *((unsigned long *)&__m128i_result1) = 0x0001918000017160; ++ *((unsigned long *)&__m128i_result0) = 0x0001514000013120; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffff60ca7104649; ++ *((unsigned long *)&__m128i_op00) = 0xfffff790a15db63d; ++ *((unsigned long *)&__m128i_result1) = 0xfffffc00ffde4000; ++ *((unsigned long *)&__m128i_result0) = 0xfe857400fed8f400; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x1c6c80007fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0038d800ff000000; ++ *((unsigned long *)&__m128i_result0) = 0x00fffe00fffffe00; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op00) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff800000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff800000000000; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsllwil_w_h (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001fffe00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000007fff800000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff80ff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xffff80000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000001fffe; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000104000800; ++ *((unsigned long *)&__m128i_result1) = 0x0000040004000000; ++ *((unsigned long *)&__m128i_result0) = 0x0010002000000000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000017fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000800000; ++ *((unsigned long *)&__m128i_result0) = 0x003fffffff800000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x57f160c4a1750eda; ++ *((unsigned long *)&__m128i_result1) = 0x000002bf8b062000; ++ *((unsigned long *)&__m128i_result0) = 0xfffffd0ba876d000; ++ __m128i_out = __lsx_vsllwil_d_w (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-2.c +new file mode 100644 +index 000000000..5f46293dc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsllwil-2.c +@@ -0,0 +1,189 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000007f7f02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00003f803f800100; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0014000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f807f807f807f80; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001030103; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0020006000200060; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0808080808080805; ++ *((unsigned long *)&__m128i_op00) = 0x0808080808080805; ++ *((unsigned long *)&__m128i_result1) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_result0) = 0x0020002000200014; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0001fffe0001fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000201fe01fc; ++ *((unsigned long *)&__m128i_result0) = 0x0000000201fe01fc; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff1affff01001fe0; ++ *((unsigned long *)&__m128i_op00) = 0xff1aff6d02834d70; ++ *((unsigned long *)&__m128i_result1) = 0x7f800d007f803680; ++ *((unsigned long *)&__m128i_result0) = 0x0100418026803800; ++ __m128i_out = __lsx_vsllwil_hu_bu (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3e2b34ca59fa4c88; ++ *((unsigned long *)&__m128i_op00) = 0x3b2c8aefd44be966; ++ *((unsigned long *)&__m128i_result1) = 0x0007658000115de0; ++ *((unsigned long *)&__m128i_result0) = 0x001a8960001d2cc0; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffff000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ff00; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ff00; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000040600000406; ++ *((unsigned long *)&__m128i_op00) = 0x020202020202fe02; ++ *((unsigned long *)&__m128i_result1) = 0x0020200000202000; ++ *((unsigned long *)&__m128i_result0) = 0x002020000fe02000; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000001ffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000002; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3131313131313131; ++ *((unsigned long *)&__m128i_result1) = 0x0313100003131000; ++ *((unsigned long *)&__m128i_result0) = 0x0313100003131000; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000900000009; ++ *((unsigned long *)&__m128i_op00) = 0x0000000900000009; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000090; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000090; ++ __m128i_out = __lsx_vsllwil_wu_hu (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x000000020000007d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000800000; ++ *((unsigned long *)&__m128i_result0) = 0x000000001f400000; ++ __m128i_out = __lsx_vsllwil_du_wu (__m128i_op0, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000280000; ++ __m128i_out = __lsx_vsllwil_du_wu (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000fef01000e27ca; ++ *((unsigned long *)&__m128i_result1) = 0x0000001fde020000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001c4f940000; ++ __m128i_out = __lsx_vsllwil_du_wu (__m128i_op0, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000ffffffff00; ++ *((unsigned long *)&__m128i_result0) = 0x000000ffffffff00; ++ __m128i_out = __lsx_vsllwil_du_wu (__m128i_op0, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_result1) = 0x00000fffffffe000; ++ *((unsigned long *)&__m128i_result0) = 0x0000102020204000; ++ __m128i_out = __lsx_vsllwil_du_wu (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000008000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsllwil_du_wu (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ *((unsigned long *)&__m128i_op01) = 0x8d78336c83652b86; ++ *((unsigned long *)&__m128i_op00) = 0x39c51f389c0d6112; ++ *((unsigned long *)&__m128i_result1) = 0x00000001ce28f9c0; ++ *((unsigned long *)&__m128i_result0) = 0x00000004e06b0890; ++ __m128i_out = __lsx_vsllwil_du_wu (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrl.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrl.c +new file mode 100644 +index 000000000..f9c789855 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrl.c +@@ -0,0 +1,389 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_op00) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffefffffffef; ++ *((unsigned long *)&__m128i_result0) = 0xffffffefffffffef; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0101010100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_op00) = 0x0000005555555554; ++ *((unsigned long *)&__m128i_op11) = 0x00000001000f000e; ++ *((unsigned long *)&__m128i_op10) = 0x0000fff1000ffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000002a55005501; ++ *((unsigned long *)&__m128i_result0) = 0x0000002a55000001; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80000000fff8fff8; ++ *((unsigned long *)&__m128i_op00) = 0x80000000fff80000; ++ *((unsigned long *)&__m128i_op11) = 0x7f800000fff8fff8; ++ *((unsigned long *)&__m128i_op10) = 0x7f800000fff80000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_result0) = 0x80000000fff80000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0004000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0004000000040000; ++ *((unsigned long *)&__m128i_op11) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_op10) = 0xfff6fff6fff6fff6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000750500006541; ++ *((unsigned long *)&__m128i_op10) = 0x00000100fffffefd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x00f900d7003d00e4; ++ *((unsigned long *)&__m128i_op10) = 0x003e00d100de002b; ++ *((unsigned long *)&__m128i_result1) = 0x7f4000007f040000; ++ *((unsigned long *)&__m128i_result0) = 0x7f0200007f020000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffe000000f6; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x01010101ffffff00; ++ *((unsigned long *)&__m128i_result0) = 0x01010101000000f6; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffffff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000049000000c0; ++ *((unsigned long *)&__m128i_op10) = 0x00000001ffffff29; ++ *((unsigned long *)&__m128i_result1) = 0x00ffff7f00ff00ff; ++ *((unsigned long *)&__m128i_result0) = 0x00ff007f0101017f; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff2900000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000401000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffff2900000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vsrl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xc2f9bafac2fac2fa; ++ *((unsigned long *)&__m128i_result1) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101080408040804; ++ *((unsigned long *)&__m128i_op00) = 0x0804080407040804; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000010a000b; ++ *((unsigned long *)&__m128i_result1) = 0x0101080408040804; ++ *((unsigned long *)&__m128i_result0) = 0x000100810080e081; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x4688500046f6a000; ++ *((unsigned long *)&__m128i_op10) = 0x4f8000004f7fff02; ++ *((unsigned long *)&__m128i_result1) = 0x00ffffff03ffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00013fff; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffe; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000021ffffffdf; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000e60; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op00) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op11) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op10) = 0x0202fe02fd020102; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x0400040004000400; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101fe870101fe87; ++ *((unsigned long *)&__m128i_op00) = 0x0101fe8700000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x61608654a2d4f6da; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000fb01; ++ *((unsigned long *)&__m128i_op00) = 0x0000000007000000; ++ *((unsigned long *)&__m128i_op11) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000fb01; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000e0000; ++ __m128i_out = __lsx_vsrl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff0000000000; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff000100ff00fe; ++ *((unsigned long *)&__m128i_op00) = 0x00ff003000ff00a0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff000100ff00fe; ++ *((unsigned long *)&__m128i_result0) = 0x00ff003000ff00a0; ++ __m128i_out = __lsx_vsrl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100010100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffe0000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffe0000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffe0000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffe0000000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000ff00ff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ff00ff; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffe7fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000001fd02; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffe1fffffff; ++ __m128i_out = __lsx_vsrl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000900000009; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffff7fffffff7f; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff007fff810001; ++ *((unsigned long *)&__m128i_op00) = 0x000400530050ffa6; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff800fff01; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000007ff000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000056f64adb9464; ++ *((unsigned long *)&__m128i_op10) = 0x29ca096f235819c2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000004399d32; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffffffffffff; ++ __m128i_out = __lsx_vsrl_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op10) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrl_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrli.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrli.c +new file mode 100644 +index 000000000..7b5e9a7bf +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrli.c +@@ -0,0 +1,328 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0001ffff0001ffff; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000020000000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000010000000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000100000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000080000; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000017f0a82; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x03ff03ff03ff03ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000400000004000; ++ *((unsigned long *)&__m128i_op00) = 0x0000400000204010; ++ *((unsigned long *)&__m128i_result1) = 0x0000020000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000020000010200; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000006; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x000000003fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x000000003fffffff; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x37); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000007b; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0020002000200020; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffefffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffefffff; ++ *((unsigned long *)&__m128i_result1) = 0x0007000700070007; ++ *((unsigned long *)&__m128i_result0) = 0x0007000700070007; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000c000c000c000c; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000003d0000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000003d0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000030000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000030000; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00fe00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000100; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000400000000; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xaa14efac3bb62636; ++ *((unsigned long *)&__m128i_op00) = 0xd6c22c8353a80d2c; ++ *((unsigned long *)&__m128i_result1) = 0x0002000300000000; ++ *((unsigned long *)&__m128i_result0) = 0x0003000000010000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3fff3fff3fff3fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080000700000014; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffbffda; ++ *((unsigned long *)&__m128i_result1) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001010101; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffefffe; ++ *((unsigned long *)&__m128i_result1) = 0x000001fffdfffdff; ++ *((unsigned long *)&__m128i_result0) = 0x000001fffdfffdff; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op00) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_result1) = 0x001a64b345308091; ++ *((unsigned long *)&__m128i_result0) = 0x001f2f2cab1c732a; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000290; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000290; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000002; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00020000ffff0001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000003030000; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000002345454; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c0dec4ca; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000060006; ++ __m128i_out = __lsx_vsrli_h (__m128i_op0, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000200000000d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_b (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000eefff; ++ *((unsigned long *)&__m128i_op00) = 0xf8e1a03affffe3e2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000003e0000003f; ++ __m128i_out = __lsx_vsrli_w (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrli_d (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrln.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrln.c +new file mode 100644 +index 000000000..5a8f4f70a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrln.c +@@ -0,0 +1,335 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000c77c000047cd; ++ *((unsigned long *)&__m128i_op10) = 0x0000c0f100006549; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffdfff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffdfff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffe00001ffe200; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000001ffffdfff; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff35cab978; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff35cab978; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010035; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000020; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x80307028ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x8040007fffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0101ff010101; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_op00) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4180418041804180; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_op10) = 0x000fffefffefffef; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00000000; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00008bf700017052; ++ *((unsigned long *)&__m128i_op00) = 0x0000f841000091aa; ++ *((unsigned long *)&__m128i_op11) = 0xe6d4572c8a5835bc; ++ *((unsigned long *)&__m128i_op10) = 0xe5017c2ac9ca9fd0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000f8410000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001010001; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000100000001000; ++ *((unsigned long *)&__m128i_op00) = 0x0ed5ced7e51023e5; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00001000e51023e5; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffbfff8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010001; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000020002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000020002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x000000017ffeffff; ++ *((unsigned long *)&__m128i_op10) = 0x000000017ffeffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x379674c000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3789f68000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfefeff00fefeff00; ++ *((unsigned long *)&__m128i_op10) = 0xfefeff00fefeff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00c0000000800000; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x9c7c266e71768fa4; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000071768fa4; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffdfdc0d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffdfdc0d; ++ __m128i_out = __lsx_vsrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000246d9755; ++ *((unsigned long *)&__m128i_op10) = 0x000000002427c2ee; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlni.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlni.c +new file mode 100644 +index 000000000..ca462c834 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlni.c +@@ -0,0 +1,281 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op10) = 0x1e801ffc7fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00003fe00ffe3fe0; ++ __m128i_out = __lsx_vsrlni_w_d (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00ff00ff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_b_h (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000001f; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x7b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_w_d (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc39fffff007fffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000fe00fd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x78c00000ff000000; ++ *((unsigned long *)&__m128i_result1) = 0x61cf003f0000007f; ++ *((unsigned long *)&__m128i_result0) = 0x000000003c607f80; ++ __m128i_out = __lsx_vsrlni_h_w (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff7f01ff01; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff7f01ff01; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffe03; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffe03; ++ __m128i_out = __lsx_vsrlni_h_w (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff8001ffff8001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_result0) = 0x000fffefffefffef; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x4b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363797c63990099; ++ *((unsigned long *)&__m128i_op00) = 0x171f0a1f6376441f; ++ *((unsigned long *)&__m128i_op11) = 0x6363797c63990099; ++ *((unsigned long *)&__m128i_op10) = 0x171f0a1f6376441f; ++ *((unsigned long *)&__m128i_result1) = 0x181e180005021811; ++ *((unsigned long *)&__m128i_result0) = 0x181e180005021811; ++ __m128i_out = __lsx_vsrlni_b_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00003fff00003fff; ++ __m128i_out = __lsx_vsrlni_h_w (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf0fd800080000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000a00028004000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000f000800000002; ++ *((unsigned long *)&__m128i_result0) = 0x000f000000000000; ++ __m128i_out = __lsx_vsrlni_h_w (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_w_d (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xaeaeaeaeaeaeae35; ++ *((unsigned long *)&__m128i_op00) = 0xaeaeaeaeaeaeae35; ++ *((unsigned long *)&__m128i_op11) = 0xaeaeaeaeaeaeae35; ++ *((unsigned long *)&__m128i_op10) = 0xaeaeaeaeaeaeae35; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000002; ++ __m128i_out = __lsx_vsrlni_w_d (__m128i_op0, __m128i_op1, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_h_w (__m128i_op0, __m128i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00000000; ++ __m128i_out = __lsx_vsrlni_b_h (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000008140c80; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000008140c80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_result0) = 0x0000000002050320; ++ __m128i_out = __lsx_vsrlni_w_d (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_op00) = 0x0000000002050320; ++ *((unsigned long *)&__m128i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op10) = 0x010101017f010101; ++ *((unsigned long *)&__m128i_result1) = 0x0000040600000406; ++ *((unsigned long *)&__m128i_result0) = 0x020202020202fe02; ++ __m128i_out = __lsx_vsrlni_b_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0xe364525335ede000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000fff00000e36; ++ __m128i_out = __lsx_vsrlni_w_d (__m128i_op0, __m128i_op1, 0x34); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x601fbfbeffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffb00fdfdf7ffff; ++ *((unsigned long *)&__m128i_result0) = 0xfff8000000000000; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_h_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrlni_h_w (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000455555555; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000008; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_w_d (__m128i_op0, __m128i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7c7c000000007176; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000001f1f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000bffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000040001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x6d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe4c8b96e2560afe9; ++ *((unsigned long *)&__m128i_op00) = 0xc001a1867fffa207; ++ *((unsigned long *)&__m128i_op11) = 0xe4c8b96e2560afe9; ++ *((unsigned long *)&__m128i_op10) = 0xc001a1867fffa207; ++ *((unsigned long *)&__m128i_result1) = 0xe2560afe9c001a18; ++ *((unsigned long *)&__m128i_result0) = 0xe2560afe9c001a18; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x24); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000042ab41; ++ *((unsigned long *)&__m128i_op00) = 0xb1b1b1b1b16f0670; ++ *((unsigned long *)&__m128i_op11) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op10) = 0x0000000044470000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000100; ++ __m128i_out = __lsx_vsrlni_b_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000080c43b700; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x56); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_op00) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_op11) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_op10) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_result1) = 0x022002101b200203; ++ *((unsigned long *)&__m128i_result0) = 0x022002101b200203; ++ __m128i_out = __lsx_vsrlni_d_q (__m128i_op0, __m128i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlni_b_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlr.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlr.c +new file mode 100644 +index 000000000..211339bb8 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlr.c +@@ -0,0 +1,434 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x43e092728266beba; ++ *((unsigned long *)&__m128i_op10) = 0x43d8969cc4afbf2d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x7f8000007f800000; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0xfffc001fffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffff8000; ++ *((unsigned long *)&__m128i_result0) = 0x0010000200020002; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffff0ffe04000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000200010; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff01ff01; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000101fd01fe; ++ *((unsigned long *)&__m128i_result1) = 0xff80ff80ff80ff80; ++ *((unsigned long *)&__m128i_result0) = 0xff80ff8080008000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf51cf8dad6040188; ++ *((unsigned long *)&__m128i_op00) = 0x0982e2daf234ed87; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffff51cf8da; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffd6040188; ++ *((unsigned long *)&__m128i_result1) = 0x00020002000d0000; ++ *((unsigned long *)&__m128i_result0) = 0x000000020f2300ee; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007f8000007f80; ++ *((unsigned long *)&__m128i_op00) = 0x00007f8000007f80; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000003fc; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000003fc; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000006; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result1) = 0x0040000000400000; ++ *((unsigned long *)&__m128i_result0) = 0x0040000000400000; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0020808100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe218ffffea10; ++ *((unsigned long *)&__m128i_op00) = 0xfffff208fffffa02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffe218ffffea10; ++ *((unsigned long *)&__m128i_result0) = 0xfffff208fffffa02; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x111110ff11111141; ++ *((unsigned long *)&__m128i_op00) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000f00f; ++ *((unsigned long *)&__m128i_result1) = 0x111110ff11111141; ++ *((unsigned long *)&__m128i_result0) = 0x1111113111111100; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1f54e0ab00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x000000003fbf3fbf; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7ff8; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000200000100; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfeca2eb9931; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00d3007c014e00bd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200020002; ++ *((unsigned long *)&__m128i_result0) = 0x06e1000e00030005; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0202020202020202; ++ *((unsigned long *)&__m128i_op00) = 0x363d753d50155c0a; ++ *((unsigned long *)&__m128i_op11) = 0xe500c085c000c005; ++ *((unsigned long *)&__m128i_op10) = 0xe5c1a185c48004c5; ++ *((unsigned long *)&__m128i_result1) = 0x0002020002020200; ++ *((unsigned long *)&__m128i_result0) = 0x021f3b0205150600; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffe000ffdf; ++ *((unsigned long *)&__m128i_op11) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffe000ffdf; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffe080f6efc100f7; ++ *((unsigned long *)&__m128i_op10) = 0xefd32176ffe100f7; ++ *((unsigned long *)&__m128i_result1) = 0x0000040000000200; ++ *((unsigned long *)&__m128i_result0) = 0x0000040000000000; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffdfe01; ++ *((unsigned long *)&__m128i_op10) = 0xfffdfe0200000002; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4000000000000000; ++ __m128i_out = __lsx_vsrlr_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_op00) = 0xa352bfac9269e0aa; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xd70b30c96ea9f4e8; ++ *((unsigned long *)&__m128i_result0) = 0xa352bfac9269e0aa; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000005; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000158; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00009c7c00007176; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000001fffeff98; ++ *((unsigned long *)&__m128i_op00) = 0x0014ffe4ff76ffc4; ++ *((unsigned long *)&__m128i_op11) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op10) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000010; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x084d1a0907151a3d; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfff9fffefff9ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0280000000000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0700f8ff0700f8ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0700f8ff0700f8ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x3bc000003a800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000f50000000900; ++ *((unsigned long *)&__m128i_op10) = 0x0000090a00000998; ++ *((unsigned long *)&__m128i_result1) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_result0) = 0x000ef0000000003b; ++ __m128i_out = __lsx_vsrlr_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0005847b00011005; ++ *((unsigned long *)&__m128i_op00) = 0x0005847b00000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000807bf0a1f80; ++ *((unsigned long *)&__m128i_op10) = 0x00000800ecedee68; ++ *((unsigned long *)&__m128i_result1) = 0x0005840100000005; ++ *((unsigned long *)&__m128i_result0) = 0x0005847b00000000; ++ __m128i_out = __lsx_vsrlr_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128i_op00) = 0x00a975be00accf03; ++ *((unsigned long *)&__m128i_op11) = 0x00250023001c001d; ++ *((unsigned long *)&__m128i_op10) = 0x309d2f342a5d2b34; ++ *((unsigned long *)&__m128i_result1) = 0x00060eb000000006; ++ *((unsigned long *)&__m128i_result0) = 0x0000075c00000cf0; ++ __m128i_out = __lsx_vsrlr_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlri.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlri.c +new file mode 100644 +index 000000000..2c3a53416 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlri.c +@@ -0,0 +1,300 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op00) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_result1) = 0x0005252800052528; ++ *((unsigned long *)&__m128i_result0) = 0x0005252800052528; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0200020002000200; ++ *((unsigned long *)&__m128i_result0) = 0x0200020002000200; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffc001fffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000200000; ++ *((unsigned long *)&__m128i_result0) = 0x001fff8004000000; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0010001000030000; ++ *((unsigned long *)&__m128i_op00) = 0x00060001fffe8003; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000200010; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000078c00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000078c00000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x4000400000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000040004000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001800390049ffaa; ++ *((unsigned long *)&__m128i_op00) = 0x0029ff96005cff88; ++ *((unsigned long *)&__m128i_result1) = 0x001800390049ffaa; ++ *((unsigned long *)&__m128i_result0) = 0x0029ff96005cff88; ++ __m128i_out = __lsx_vsrlri_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03c0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x03c0038000000380; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xa2a2a2a3a2a2a2a3; ++ *((unsigned long *)&__m128i_op00) = 0xc605c000aedd0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000005151515; ++ *((unsigned long *)&__m128i_result0) = 0x0000000006302e00; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2000200000013fa0; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000013fa0; ++ *((unsigned long *)&__m128i_result1) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000020000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000020000000; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x23); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_op00) = 0x370bdfecffecffec; ++ *((unsigned long *)&__m128i_result1) = 0x00000dc300003ffb; ++ *((unsigned long *)&__m128i_result0) = 0x00000dc300003ffb; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8080808000000035; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200000000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00018d8e00018d8e; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f801fe000000000; ++ *((unsigned long *)&__m128i_op00) = 0x3fc03fc000000004; ++ *((unsigned long *)&__m128i_result1) = 0x00000003fc00ff00; ++ *((unsigned long *)&__m128i_result0) = 0x00000001fe01fe00; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200020002; ++ __m128i_out = __lsx_vsrlri_b (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_result0) = 0x8000800080008000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x045340a628404044; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001030103; ++ __m128i_out = __lsx_vsrlri_b (__m128i_op0, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlri_h (__m128i_op0, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x86dd8341b164f12b; ++ *((unsigned long *)&__m128i_op00) = 0x9611c3985b3159f5; ++ *((unsigned long *)&__m128i_result1) = 0x0021b761002c593c; ++ *((unsigned long *)&__m128i_result0) = 0x002584710016cc56; ++ __m128i_out = __lsx_vsrlri_w (__m128i_op0, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_op00) = 0xbbc8ecc5f3ced5f3; ++ *((unsigned long *)&__m128i_result1) = 0xc0b4d1a5f8babad3; ++ *((unsigned long *)&__m128i_result0) = 0xbbc8ecc5f3ced5f3; ++ __m128i_out = __lsx_vsrlri_d (__m128i_op0, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000feff23560000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fd1654860000; ++ *((unsigned long *)&__m128i_result1) = 0x0000080801030000; ++ *((unsigned long *)&__m128i_result0) = 0x0000080103040000; ++ __m128i_out = __lsx_vsrlri_b (__m128i_op0, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrn.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrn.c +new file mode 100644 +index 000000000..c630b4261 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrn.c +@@ -0,0 +1,164 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001ffff0001ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x00000000efffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vsrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000040400000383; ++ *((unsigned long *)&__m128i_op00) = 0xffffe000ffff1fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000383ffff1fff; ++ __m128i_out = __lsx_vsrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000003fc; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000003fc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x002affd600000001; ++ *((unsigned long *)&__m128i_op00) = 0xcbc2723a4f12a5f8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffd60001723aa5f8; ++ __m128i_out = __lsx_vsrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op00) = 0x467f6080467d607f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808081; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xe000e0006080b040; ++ __m128i_out = __lsx_vsrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010101030101; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101030101; ++ *((unsigned long *)&__m128i_op11) = 0x00000000fffa0000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffa0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101000101010001; ++ __m128i_out = __lsx_vsrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff80ffffffffff80; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff80ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x6a5d5b056f2f4978; ++ *((unsigned long *)&__m128i_op10) = 0x17483c07141b5971; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0800010001ff8000; ++ __m128i_out = __lsx_vsrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff01ff01ac025c87; ++ *((unsigned long *)&__m128i_op10) = 0xff01ff01ac465ca1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrni.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrni.c +new file mode 100644 +index 000000000..468a17c15 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vsrlrni.c +@@ -0,0 +1,686 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffff8969ffffd7e2; ++ *((unsigned long *)&__m128i_op10) = 0x0000d688ffffbd95; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xf12dfafc1ad1f7b3; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x34); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op11) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_op10) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000100; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000c0002000c0002; ++ *((unsigned long *)&__m128i_op00) = 0x000400c600700153; ++ *((unsigned long *)&__m128i_op11) = 0x000c0002000c0002; ++ *((unsigned long *)&__m128i_op10) = 0x000400c600700153; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000010000007f; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0800000400000800; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000001515151500; ++ *((unsigned long *)&__m128i_op10) = 0x0000001515151500; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001515000015150; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fdfd0404; ++ *((unsigned long *)&__m128i_op11) = 0x3fffffff3fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x3fffffff3fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000fc08; ++ *((unsigned long *)&__m128i_result0) = 0x8000800080008000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000fc08; ++ *((unsigned long *)&__m128i_op00) = 0x8000800080008000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffba420000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x000007e044000400; ++ *((unsigned long *)&__m128i_result0) = 0xfdd2100000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000081e003f3f3f; ++ *((unsigned long *)&__m128i_op00) = 0x3f3f3f0e00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000081e003f3f3f; ++ *((unsigned long *)&__m128i_op10) = 0x3f3f3f0e00000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000103c007e7e8; ++ *((unsigned long *)&__m128i_result0) = 0x00000103c007e7e8; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x43); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0202022302023212; ++ *((unsigned long *)&__m128i_op00) = 0x0202ff3f02022212; ++ *((unsigned long *)&__m128i_op11) = 0x0000002100003010; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff3f00002010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x79); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xe2bb5ff00e20aceb; ++ *((unsigned long *)&__m128i_op10) = 0xe2bb5ff00e20aceb; ++ *((unsigned long *)&__m128i_result1) = 0x0100010000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00e3000e00e3000e; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf58df7841423142a; ++ *((unsigned long *)&__m128i_op10) = 0x3f7477f8ff4e2152; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3d3e0505101e4008; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2bd5d429e34a1efb; ++ *((unsigned long *)&__m128i_op00) = 0xfc0203fccbedbba7; ++ *((unsigned long *)&__m128i_op11) = 0xc9f66947f077afd0; ++ *((unsigned long *)&__m128i_op10) = 0x89fed7c07fdf5d00; ++ *((unsigned long *)&__m128i_result1) = 0x14f1a50ffe65f6de; ++ *((unsigned long *)&__m128i_result0) = 0xa3f83bd8e03fefaf; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x6ed694e00e0355db; ++ *((unsigned long *)&__m128i_op10) = 0x0000010600000106; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xe00e035606000001; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xe739e7ade77ae725; ++ *((unsigned long *)&__m128i_op00) = 0xbb9013bd049bc9ec; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x56aca41400000000; ++ *((unsigned long *)&__m128i_result1) = 0x7ade77ae3bd049bd; ++ *((unsigned long *)&__m128i_result0) = 0x0000000041400000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x1010101010101010; ++ *((unsigned long *)&__m128i_op10) = 0x1010101010101010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8081808180818081; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000006ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0037f80000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x69); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x0080808080c04040; ++ *((unsigned long *)&__m128i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op10) = 0x0101010001808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000202000008081; ++ *((unsigned long *)&__m128i_result0) = 0x0001010100010101; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0010000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00fff00000001000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x6b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000adf0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001e00; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0040000000400040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000020002020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808102; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001010102; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001000100010000b; ++ *((unsigned long *)&__m128i_op00) = 0x03fc03fc03fc03fc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x04000400ff01ff01; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1010101010101010; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000fff800000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000001ed68; ++ *((unsigned long *)&__m128i_op11) = 0x1ff6a09e667f3bd8; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000007b5a; ++ *((unsigned long *)&__m128i_result0) = 0x999fcef600000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffe5c8000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x91f80badc162a0c4; ++ *((unsigned long *)&__m128i_op10) = 0x99d1ffff0101ff01; ++ *((unsigned long *)&__m128i_result1) = 0x00ff400000000000; ++ *((unsigned long *)&__m128i_result0) = 0x905d0b06cf0008f8; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x3802f4fd025800f7; ++ *((unsigned long *)&__m128i_op11) = 0xc8ff0bffff00ffae; ++ *((unsigned long *)&__m128i_op10) = 0x91ff40fffff8ff50; ++ *((unsigned long *)&__m128i_result1) = 0x0000200000000700; ++ *((unsigned long *)&__m128i_result0) = 0x0000192000001240; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x33); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff0ffd0ffd; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff0ffc0001; ++ *((unsigned long *)&__m128i_op11) = 0xbb7743ca4c78461f; ++ *((unsigned long *)&__m128i_op10) = 0xd9743eb5fb4deb3a; ++ *((unsigned long *)&__m128i_result1) = 0x003fffffffc3ff44; ++ *((unsigned long *)&__m128i_result0) = 0x002eddd0f2931e12; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x4a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbb7743ca4c78461f; ++ *((unsigned long *)&__m128i_op00) = 0xd9743eb5fb4deb3a; ++ *((unsigned long *)&__m128i_op11) = 0x22445e1ad9c3e4f0; ++ *((unsigned long *)&__m128i_op10) = 0x1b43e8a30a570a63; ++ *((unsigned long *)&__m128i_result1) = 0x743ca4c843eb5fb5; ++ *((unsigned long *)&__m128i_result0) = 0x45e1ad9c3e8a30a5; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x1204900f62f72565; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x4901725600000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x6a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000400000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000300000003; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3f3f3f7fbf3fffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x47); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000040804080; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000020100000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffe8ffff28fc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffa; ++ *((unsigned long *)&__m128i_op11) = 0x00007fff0000803e; ++ *((unsigned long *)&__m128i_op10) = 0x00000006ffff81e1; ++ *((unsigned long *)&__m128i_result1) = 0x0ffffffe8ffff290; ++ *((unsigned long *)&__m128i_result0) = 0x000007fff0000804; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x44); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000418200000008e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000002100047; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636362; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636362; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636362; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636362; ++ *((unsigned long *)&__m128i_result1) = 0x0032003200320032; ++ *((unsigned long *)&__m128i_result0) = 0x0032003200320032; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff01010102; ++ *((unsigned long *)&__m128i_op00) = 0x7ffdf87f0b0c7f7f; ++ *((unsigned long *)&__m128i_op11) = 0xf6b3eb63f6b3f6b3; ++ *((unsigned long *)&__m128i_op10) = 0x363953e42b56432e; ++ *((unsigned long *)&__m128i_result1) = 0x010000010080000b; ++ *((unsigned long *)&__m128i_result0) = 0x00f700f70036002b; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xed67d6c7ed67ed67; ++ *((unsigned long *)&__m128i_op10) = 0x6c72a7c856ac865c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000700000003; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff40ff83; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1010101010101010; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000003030103; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000003030103; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000006060; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000006060; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000002408beb26c8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000706e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000028c27; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000070; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80000b0b80000b0b; ++ *((unsigned long *)&__m128i_op00) = 0x8000101080001010; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffefefffffeff0; ++ *((unsigned long *)&__m128i_result1) = 0x0061006100020002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000fe00fe; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000078087f08; ++ *((unsigned long *)&__m128i_op10) = 0x0000000078087f08; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000e0fc0000e0fc; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ff0bff76; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x75); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x33); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff00ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x000000ff00ffffff; ++ *((unsigned long *)&__m128i_op11) = 0x8282828282828282; ++ *((unsigned long *)&__m128i_op10) = 0x0000828282828282; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0008000800000008; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00f7000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000005150; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000005150; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000f7000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x24); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x41afddcb1c000000; ++ *((unsigned long *)&__m128i_op11) = 0xd09e1bd99a2c6eb1; ++ *((unsigned long *)&__m128i_op10) = 0xe82f7c27bb0778af; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000040002; ++ *((unsigned long *)&__m128i_result0) = 0x000d000a000f000c; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffff8000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffdff0; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x0144329880000000; ++ *((unsigned long *)&__m128i_result1) = 0x007fffc0007ffff0; ++ *((unsigned long *)&__m128i_result0) = 0x004000004c400000; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x17); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000001e0000001e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffafff0fff9ff01; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result1) = 0x00000000d800cff8; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vsrlrni_h_w (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x00000002000007d7; ++ *((unsigned long *)&__m128i_op10) = 0x0000000300000ff1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x000007d700000ff1; ++ __m128i_out = __lsx_vsrlrni_w_d (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op11) = 0xffffff00ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffff00ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000ff8; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001000; ++ __m128i_out = __lsx_vsrlrni_d_q (__m128i_op0, __m128i_op1, 0x74); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000f08; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x2020202020202020; ++ __m128i_out = __lsx_vsrlrni_b_h (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-SX-vector-vssran-vssrani-vss.patch
Added
@@ -0,0 +1,4954 @@ +From 1009120c617c050d02a6d2abe786728dccf5cb5b Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Tue, 12 Sep 2023 11:17:38 +0800 +Subject: PATCH 091/124 LoongArch: Add tests for SX vector + vssran/vssrani/vssrarn/vssrarni/vssrln /vssrlni/vssrlrn/vssrlrni + instructions. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vssran.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssrani.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssrarn.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssrarni.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssrln.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssrlni.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssrlrn.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vssrlrni.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vssran.c | 390 ++++++++ + .../loongarch/vector/lsx/lsx-vssrani.c | 679 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vssrarn.c | 669 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vssrarni.c | 848 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vssrln.c | 543 +++++++++++ + .../loongarch/vector/lsx/lsx-vssrlni.c | 668 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vssrlrn.c | 470 ++++++++++ + .../loongarch/vector/lsx/lsx-vssrlrni.c | 597 ++++++++++++ + 8 files changed, 4864 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssran.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrani.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarni.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrln.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlni.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrn.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrni.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssran.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssran.c +new file mode 100644 +index 000000000..e45ca36f0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssran.c +@@ -0,0 +1,390 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x003f00000000003f; ++ *((unsigned long *)&__m128i_op10) = 0x003f000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000001000001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffc000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fff0000; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffefffffffeff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffcff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x02b504f305a5c091; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x02b504f305a5c091; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000005602d2; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000003f80b0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_op11) = 0xb327b9363c992b2e; ++ *((unsigned long *)&__m128i_op10) = 0xa1e7b475d925730f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000001ff00; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0060e050007f0160; ++ *((unsigned long *)&__m128i_op10) = 0x0040007fff800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ffffff00ff00ff; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x1268f057137a0267; ++ *((unsigned long *)&__m128i_op10) = 0x0048137ef886fae0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000000; ++ __m128i_out = __lsx_vssran_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_op10) = 0x0141010101410101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op00) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op11) = 0x75b043c4d17db125; ++ *((unsigned long *)&__m128i_op10) = 0xeef8227b4f8017b1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x027c027c000027c0; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000006f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000006f00000000; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffd000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff994db09c; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffc7639d96; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op00) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssran_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_op00) = 0x0fff0fff0fff0fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssran_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0x9); ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x7f80000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x800080007f008000; ++ __m128i_out = __lsx_vssran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000695d00009b8f; ++ *((unsigned long *)&__m128i_op00) = 0x000074f20000d272; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00001f5400000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff000000ff0000; ++ __m128i_out = __lsx_vssran_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00010000fffffffc; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x00010000fffffffc; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff00000000; ++ __m128i_out = __lsx_vssran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x31b1777777777776; ++ *((unsigned long *)&__m128i_op00) = 0x6eee282828282829; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000006362ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ff801c9e; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000810000; ++ *((unsigned long *)&__m128i_op11) = 0x40eff02383e383e4; ++ *((unsigned long *)&__m128i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000800000007fff; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffb00fdfdf7ffff; ++ *((unsigned long *)&__m128i_op00) = 0xfff8000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000c0c00000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000a74aa8a55ab; ++ *((unsigned long *)&__m128i_op00) = 0x6adeb5dfcb000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0a7480007fff8000; ++ __m128i_out = __lsx_vssran_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000fe00fe; ++ *((unsigned long *)&__m128i_op00) = 0x00fe00fe00fe00fe; ++ *((unsigned long *)&__m128i_op11) = 0x0000f50000007500; ++ *((unsigned long *)&__m128i_op10) = 0x00007e1600007d98; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00fe00fe7fffffff; ++ __m128i_out = __lsx_vssran_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4f4f4f4f4f4f0000; ++ *((unsigned long *)&__m128i_op00) = 0x4f4f4f4f4f4f0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f7f007f7f7f00; ++ __m128i_out = __lsx_vssran_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrani.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrani.c +new file mode 100644 +index 000000000..7ffcecde7 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrani.c +@@ -0,0 +1,679 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00001802041b0013; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000007f7f02; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff7fffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xff7fffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffff7ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x64); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_h_w (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_h_w (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x47); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0004007c00fc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffffffc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f7f7f7f00107f04; ++ *((unsigned long *)&__m128i_op00) = 0x7f0000fd7f0000fd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00cf01fe01fe01fe; ++ *((unsigned long *)&__m128i_op00) = 0x000301de01fe01fe; ++ *((unsigned long *)&__m128i_op11) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffc002000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0f00000000000000; ++ __m128i_out = __lsx_vssrani_bu_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xe31c86e90cda86f7; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000000e3; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x38); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc39fffff007fffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000fe00fd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffff0e700000000; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op10) = 0xffffff0000010000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_hu_w (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfc01fd1300000001; ++ *((unsigned long *)&__m128i_op10) = 0xfe00fd1400010000; ++ *((unsigned long *)&__m128i_result1) = 0x7f0000007f000000; ++ *((unsigned long *)&__m128i_result0) = 0x8080000180800100; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fff7fc01; ++ *((unsigned long *)&__m128i_op11) = 0x82c539ffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xc72df14afbfafdf9; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x23); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_hu_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000c0; ++ *((unsigned long *)&__m128i_op10) = 0x00000001ffffff29; ++ *((unsigned long *)&__m128i_result1) = 0x0000000020000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000183fffffe5; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000080000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff000000ff0000; ++ __m128i_out = __lsx_vssrani_bu_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fefefe6a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000fbf9; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000007f8; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0a000a000a000a00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x4d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f007f007f007f00; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x000000030000003f; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff0003003f; ++ __m128i_out = __lsx_vssrani_hu_w (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_hu_w (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x4c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x11000f2010000e20; ++ *((unsigned long *)&__m128i_op00) = 0x0f000d200e000c20; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x007b01ec007b3a9e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fff9fff9; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fff9fffa; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007ffe7ffe400000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x2a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc485edbcc0000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000c485; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x21011f3f193d173b; ++ *((unsigned long *)&__m128i_op00) = 0xff39ff37ff35ff33; ++ *((unsigned long *)&__m128i_op11) = 0x0000000015d926c7; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000e41b; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ff; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000007f7f7f7f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c0c0c0c0; ++ *((unsigned long *)&__m128i_op11) = 0x0014000100000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x35); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x00003f80000000ff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffff46; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x4c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000001; ++ *((unsigned long *)&__m128i_op00) = 0xffffffee00000004; ++ *((unsigned long *)&__m128i_op11) = 0x3a3a3a3b3a3a3a3a; ++ *((unsigned long *)&__m128i_op10) = 0x3a3a00003a3a0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000003a0000003a; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0x38); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000080000068; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000038003; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000040033; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_bu_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00001fff00001fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000007ffc000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffe0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000fff0; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000004000000040; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_h_w (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00fe000100cf005f; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000005e94; ++ *((unsigned long *)&__m128i_op00) = 0x00005e96ffffb402; ++ *((unsigned long *)&__m128i_op11) = 0x00fe000100cf005f; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000000bd; ++ *((unsigned long *)&__m128i_result0) = 0x0001fc0000fffeff; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000002fffffffb; ++ *((unsigned long *)&__m128i_op00) = 0x000000010000fffb; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000bffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x42); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x79); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000777777777777; ++ *((unsigned long *)&__m128i_op10) = 0xffff7777ffff7777; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000003bbbbbbbbbb; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x45); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_h_w (__m128i_op0, __m128i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0010000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0007fff800000000; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x6a5d5b056f2f4978; ++ *((unsigned long *)&__m128i_op10) = 0x17483c07141b5971; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xd4bade5e2e902836; ++ __m128i_out = __lsx_vssrani_hu_w (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0010001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x1000000010001000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_hu_w (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00680486ffffffda; ++ *((unsigned long *)&__m128i_op00) = 0xffff913bb9951901; ++ *((unsigned long *)&__m128i_op11) = 0x67157b5100005000; ++ *((unsigned long *)&__m128i_op10) = 0x387c7e0a133f2000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_result0) = 0x0c0f000a070f0204; ++ __m128i_out = __lsx_vssrani_bu_h (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_op00) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_op11) = 0x98147a504d145000; ++ *((unsigned long *)&__m128i_op10) = 0x377b810912c0e000; ++ *((unsigned long *)&__m128i_result1) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0xe); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x9c7c266e3faa293c; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000f3040705; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x86dd8341b164f12b; ++ *((unsigned long *)&__m128i_op00) = 0x9611c3985b3159f5; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xff86dd83ff9611c3; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_w_d (__m128i_op0, __m128i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op00) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_op11) = 0x1010111105050000; ++ *((unsigned long *)&__m128i_op10) = 0x4040000041410101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000808000020200; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x2e2b34ca59fa4c88; ++ *((unsigned long *)&__m128i_op10) = 0x3b2c8aefd44be966; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x2e34594c3b000000; ++ __m128i_out = __lsx_vssrani_bu_h (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff1afffefec0ec85; ++ *((unsigned long *)&__m128i_op00) = 0xff1aff6d48ce567f; ++ *((unsigned long *)&__m128i_op11) = 0xffff80c400000148; ++ *((unsigned long *)&__m128i_op10) = 0xffff80c1ffffe8de; ++ *((unsigned long *)&__m128i_result1) = 0xffe3ffd8ffe30919; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffffffff; ++ __m128i_out = __lsx_vssrani_h_w (__m128i_op0, __m128i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1313131313131313; ++ *((unsigned long *)&__m128i_op00) = 0x1313131313131313; ++ *((unsigned long *)&__m128i_op11) = 0x34947b4b11684f92; ++ *((unsigned long *)&__m128i_op10) = 0xd73691661e5b68b4; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x084d1a0907151a3d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000007d07fffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ff; ++ __m128i_out = __lsx_vssrani_b_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000014eb54ab; ++ *((unsigned long *)&__m128i_op10) = 0x14eb6a002a406a00; ++ *((unsigned long *)&__m128i_result1) = 0xe0001fffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_d_q (__m128i_op0, __m128i_op1, 0x60); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffaf1500000fffa; ++ *((unsigned long *)&__m128i_op00) = 0x0000f8a40000f310; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000003e2; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0x26); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_h_w (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf654ad7447e59090; ++ *((unsigned long *)&__m128i_op00) = 0x27b1b106b8145f50; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_wu_d (__m128i_op0, __m128i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff8ffa2fffdffb0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_du_q (__m128i_op0, __m128i_op1, 0x50); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrani_bu_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarn.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarn.c +new file mode 100644 +index 000000000..a23ad7cd2 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarn.c +@@ -0,0 +1,669 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffd24271c4; ++ *((unsigned long *)&__m128i_op10) = 0x2711bad1e8e309ed; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_op10) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op10) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0403cfcf01c1595e; ++ *((unsigned long *)&__m128i_op00) = 0x837cd5db43fc55d4; ++ *((unsigned long *)&__m128i_op11) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_op10) = 0x0404038383838404; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff80007fff; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffcb410000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffeb827ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_op10) = 0x0000000800000008; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc1bdceee242070db; ++ *((unsigned long *)&__m128i_op10) = 0xe8c7b756d76aa478; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefd7f7f7f7f7f7e; ++ *((unsigned long *)&__m128i_op00) = 0xdffdbffeba6f5543; ++ *((unsigned long *)&__m128i_op11) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ffffff000000ff; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00ffffff000000ff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000002010; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff00000000000001; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc1bdceee242070db; ++ *((unsigned long *)&__m128i_op10) = 0xe8c7b756d76aa478; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000f0; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_op10) = 0x4f804f804f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000003fffff00; ++ *((unsigned long *)&__m128i_op00) = 0x000000003fffff00; ++ *((unsigned long *)&__m128i_op11) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op10) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff000000ff00; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000007ae567a3e; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000700ff00000000; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0bd80bd80bdfffff; ++ *((unsigned long *)&__m128i_op00) = 0x0bd80bd80bd80000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x006f0efe258ca851; ++ *((unsigned long *)&__m128i_op11) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_op10) = 0xfffff00010000fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ffff00; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000f00f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0032000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000007fff; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x2020202020207f7f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000007fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff0000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111311111114111; ++ *((unsigned long *)&__m128i_op00) = 0x1111311111110000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2020202020202020; ++ *((unsigned long *)&__m128i_op00) = 0x2020202020207fff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m128i_op00) = 0x7f417f417f027e03; ++ *((unsigned long *)&__m128i_op11) = 0x9780697084f07dd7; ++ *((unsigned long *)&__m128i_op10) = 0x87e3285243051cf3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fea8ff44; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fea8ff44; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000008000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_op00) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff00; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x13f9c5b60028a415; ++ *((unsigned long *)&__m128i_op00) = 0x545cab1d81a83bea; ++ *((unsigned long *)&__m128i_op11) = 0x13f9c5b60028a415; ++ *((unsigned long *)&__m128i_op10) = 0x545cab1d81a83bea; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff0015172b; ++ __m128i_out = __lsx_vssrarn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x14ccc631eb3339ce; ++ *((unsigned long *)&__m128i_op00) = 0x685670d197a98f2e; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op00) = 0x0003c853c843c87e; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff0000ffff0000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000e36400015253; ++ *((unsigned long *)&__m128i_op00) = 0x000035ed0001e000; ++ *((unsigned long *)&__m128i_op11) = 0x0000e36400015253; ++ *((unsigned long *)&__m128i_op10) = 0x000035ed0001e000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1c6c80007fffffff; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000b4a00008808; ++ *((unsigned long *)&__m128i_op00) = 0x0808080800000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrarn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc2fc0000c3040000; ++ *((unsigned long *)&__m128i_op10) = 0xc2fc0000c3040000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000060000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000060000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0600000100000001; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0080008000800080; ++ *((unsigned long *)&__m128i_op10) = 0x0080006b00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000500000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7efefefe82010201; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff0000ff; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffff00; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op00) = 0x00ff010300ff0103; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000002ffffffff; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000045340a6; ++ *((unsigned long *)&__m128i_op00) = 0x0000000028404044; ++ *((unsigned long *)&__m128i_op11) = 0x00000fffffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x0000102020204000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x045340a628404044; ++ __m128i_out = __lsx_vssrarn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000014; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001400000014; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000adad0000adad; ++ *((unsigned long *)&__m128i_op10) = 0x000052520000adad; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xd6a09e662ab46b31; ++ *((unsigned long *)&__m128i_op00) = 0x34b8122ef4054bb3; ++ *((unsigned long *)&__m128i_op11) = 0x9c9c9c9b509be72f; ++ *((unsigned long *)&__m128i_op10) = 0x3513f2e3a1774d2c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000501ffff0005; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0021b761002c593c; ++ *((unsigned long *)&__m128i_op10) = 0x002584710016cc56; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff0000ffff; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op00) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000200000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00020000ffff0001; ++ __m128i_out = __lsx_vssrarn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x004001be00dc008e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1f3f06d4fcba4e98; ++ *((unsigned long *)&__m128i_op00) = 0x2e1135681fa8d951; ++ *((unsigned long *)&__m128i_op11) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000007d07fffffff; ++ __m128i_out = __lsx_vssrarn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_w (__m128i_op0, 0x0); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000008686; ++ *((unsigned long *)&__m128i_op00) = 0x00008e5680008685; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00007fff7fff8000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffc7f100004000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000c7f14000; ++ __m128i_out = __lsx_vssrarn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4500000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x4400000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff000000ff000000; ++ __m128i_out = __lsx_vssrarn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8a8a8a8a8a8a8a8a; ++ *((unsigned long *)&__m128i_op10) = 0x8a8a8a8a8a8a8a8a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarni.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarni.c +new file mode 100644 +index 000000000..76fac97be +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrarni.c +@@ -0,0 +1,848 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_op00) = 0x0020002000200020; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff60090958; ++ *((unsigned long *)&__m128i_op10) = 0x0fa96b88d9944d42; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00001802041b0013; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x72); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0200020002000200; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_wu_d (__m128i_op0, __m128i_op1, 0x3f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x5c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_op10) = 0x0002000000020000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xda4643d5301c4000; ++ *((unsigned long *)&__m128i_op00) = 0xc1fc0d3bf55c4000; ++ *((unsigned long *)&__m128i_op11) = 0x7505853d654185f5; ++ *((unsigned long *)&__m128i_op10) = 0x01010000fefe0101; ++ *((unsigned long *)&__m128i_result1) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_wu_d (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000fe00ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffff; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op11) = 0x00020002000d0000; ++ *((unsigned long *)&__m128i_op10) = 0x000000020f2300ee; ++ *((unsigned long *)&__m128i_result1) = 0x0400040004000400; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000000f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x79); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000073; ++ *((unsigned long *)&__m128i_op00) = 0x000000010000002b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000400000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m128i_op10) = 0x01ff01ff01ff01ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x59); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000000f0; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000000f0; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001800390049ffaa; ++ *((unsigned long *)&__m128i_op00) = 0x0029ff96005cff88; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x03c0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x03c0038000000380; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0f0000000f000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0bef0b880bd80bd8; ++ *((unsigned long *)&__m128i_op11) = 0x0bd80bd80bdfffff; ++ *((unsigned long *)&__m128i_op10) = 0x0bd80bd80bd80000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000017b017b01; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x5b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_op00) = 0xfffe0001fffe0001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x30); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x1f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xf0800320fff1fa20; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0032000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1111113111111141; ++ *((unsigned long *)&__m128i_op00) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0032000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000003f; ++ *((unsigned long *)&__m128i_op00) = 0x7f417f417f027e03; ++ *((unsigned long *)&__m128i_op11) = 0xe93d0bd19ff0c170; ++ *((unsigned long *)&__m128i_op10) = 0x5237c1bac9eadf55; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x60); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000065a0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x9941d155f43a9d08; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0c0c8b8a8b8b0b0a; ++ *((unsigned long *)&__m128i_op00) = 0x8b8a8a898a8a8909; ++ *((unsigned long *)&__m128i_op11) = 0x1817161517161514; ++ *((unsigned long *)&__m128i_op10) = 0x1615141315141312; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrarni_wu_d (__m128i_op0, __m128i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xc0fffff000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffe00000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x19); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x29); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0010001000000010; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000080000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x58); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000100fe000100fe; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x31); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0d1202e19235e2bc; ++ *((unsigned long *)&__m128i_op00) = 0xea38e0f75f6e56d1; ++ *((unsigned long *)&__m128i_op11) = 0xffffe500ffffc085; ++ *((unsigned long *)&__m128i_op10) = 0xffffc000ffffc005; ++ *((unsigned long *)&__m128i_result1) = 0xffff00000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000008; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100080000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0400400204004002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffe080f6efc100f7; ++ *((unsigned long *)&__m128i_op00) = 0xefd32176ffe100f7; ++ *((unsigned long *)&__m128i_op11) = 0xffe080f6efc100f7; ++ *((unsigned long *)&__m128i_op10) = 0xefd32176ffe100f7; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_wu_d (__m128i_op0, __m128i_op1, 0x2c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000005452505; ++ *((unsigned long *)&__m128i_op00) = 0x00000004442403e4; ++ *((unsigned long *)&__m128i_op11) = 0x03fc03fc03fc03fc; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000b4a00008808; ++ *((unsigned long *)&__m128i_result0) = 0x0808080800000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffff01; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x71); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x2ea268972ea2966a; ++ *((unsigned long *)&__m128i_op00) = 0x4026f4ffbc175bff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x5d7f5d807fea807f; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfff0fffffff00001; ++ *((unsigned long *)&__m128i_op00) = 0xfff0fffffff09515; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op10) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000ff00000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000003000000d612; ++ *((unsigned long *)&__m128i_op00) = 0x00000000bfffffff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op10) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000500000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x80808080806b000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000c0c0c000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffefffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffe1fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff7ffffffb; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000080008; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1ab6021f72496458; ++ *((unsigned long *)&__m128i_op00) = 0x7750af4954c29940; ++ *((unsigned long *)&__m128i_op11) = 0x1ab6021f72496458; ++ *((unsigned long *)&__m128i_op10) = 0x7750af4954c29940; ++ *((unsigned long *)&__m128i_result1) = 0x6ad8ffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x6ad8ffffffffffff; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op00) = 0x0002008300500088; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000088; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000020000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000010000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x2d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1200091212121212; ++ *((unsigned long *)&__m128i_result1) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_op10) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x51); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_du_q (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_h_w (__m128i_op0, __m128i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000c6c6c6c6; ++ *((unsigned long *)&__m128i_op00) = 0x00000000c6c6c6c6; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffeff98; ++ *((unsigned long *)&__m128i_op10) = 0x0014ffe4ff76ffc4; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff86dd83ff9611c3; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000035697d4e; ++ *((unsigned long *)&__m128i_op10) = 0x000000013ecaadf2; ++ *((unsigned long *)&__m128i_result1) = 0xe280e67f00000000; ++ *((unsigned long *)&__m128i_result0) = 0x00007f7f00007f80; ++ __m128i_out = __lsx_vssrarni_b_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op10) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x8000000080000000; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x017001a002c80260; ++ *((unsigned long *)&__m128i_op00) = 0x01d8000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x2e34594c3b000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vssrarni_wu_d (__m128i_op0, __m128i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00060fbf02596848; ++ *((unsigned long *)&__m128i_op00) = 0x00020fbf04581ec0; ++ *((unsigned long *)&__m128i_op11) = 0x010169d9010169d9; ++ *((unsigned long *)&__m128i_op10) = 0x01010287010146a1; ++ *((unsigned long *)&__m128i_result1) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200000001; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op00) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op11) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_op10) = 0x004d004d004d004d; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x06d9090909090909; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x48); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0039d21e3229d4e8; ++ *((unsigned long *)&__m128i_op00) = 0x6d339b4f3b439885; ++ *((unsigned long *)&__m128i_op11) = 0xfffffff000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000d00000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffc0000000000000; ++ __m128i_out = __lsx_vssrarni_d_q (__m128i_op0, __m128i_op1, 0x2e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000100000001000; ++ *((unsigned long *)&__m128i_op10) = 0x37b951002d81a921; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000075dbe982; ++ *((unsigned long *)&__m128i_op00) = 0x0000000071e48cca; ++ *((unsigned long *)&__m128i_op11) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0ebb7d300e3c9199; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrarni_w_d (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000930400008a10; ++ *((unsigned long *)&__m128i_op00) = 0x00006f9100007337; ++ *((unsigned long *)&__m128i_op11) = 0x00c2758000bccf42; ++ *((unsigned long *)&__m128i_op10) = 0x00a975be00accf03; ++ *((unsigned long *)&__m128i_result1) = 0x00250023001c001d; ++ *((unsigned long *)&__m128i_result0) = 0x309d2f342a5d2b34; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff01ffffe41f0000; ++ *((unsigned long *)&__m128i_op00) = 0xfff00000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000155; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000002b; ++ __m128i_out = __lsx_vssrarni_bu_h (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00e400ff00e400; ++ *((unsigned long *)&__m128i_op00) = 0xfee1f6f18800ff7f; ++ *((unsigned long *)&__m128i_op11) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrarni_hu_w (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrln.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrln.c +new file mode 100644 +index 000000000..ed600c72d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrln.c +@@ -0,0 +1,543 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x8080808000008080; ++ *((unsigned long *)&__m128i_op10) = 0x8080000080800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffff0000; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x5ff6a0a40ea8f47c; ++ *((unsigned long *)&__m128i_op10) = 0x5ff6a0a40e9da42a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00003ff000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000fffc00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001afffffff7; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000750500006541; ++ *((unsigned long *)&__m128i_op10) = 0x00000100fffffefd; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff00000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x80000000fff6fc00; ++ *((unsigned long *)&__m128i_op11) = 0x7f0000007f000000; ++ *((unsigned long *)&__m128i_op10) = 0x8080000180800100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff00ffff; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_b (__m128i_op0, 0x7); ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffefff6fff80002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101017f0101017f; ++ __m128i_out = __lsx_vssrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00005a5a00005a5a; ++ *((unsigned long *)&__m128i_op00) = 0x00005b5a00005b5a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00ff00ff00ff00ff; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x65b780a2ae3bf8ca; ++ *((unsigned long *)&__m128i_op10) = 0x161d0c373c200827; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000001ff; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf10cf508f904fd01; ++ *((unsigned long *)&__m128i_op10) = 0xf10cf508f904fd01; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xf8f8e018f8f8e810; ++ *((unsigned long *)&__m128i_op10) = 0xf8f8f008f8f8f800; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001ffff0003ffff0; ++ *((unsigned long *)&__m128i_op00) = 0x000fffefffefffef; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffefffef; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrln_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00007fff00007fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000f00; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff00000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000c0000bd49; ++ *((unsigned long *)&__m128i_op00) = 0x0000000c7fff000c; ++ *((unsigned long *)&__m128i_op11) = 0x00000000f0009d3c; ++ *((unsigned long *)&__m128i_op10) = 0x000000016fff9d3d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000c000000060003; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000003a24; ++ *((unsigned long *)&__m128i_op00) = 0x003dbe88077c78c1; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffe0001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00003a247fff7fff; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrln_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000003fbf3fbf; ++ *((unsigned long *)&__m128i_op00) = 0x7fff7fff7fff7ff8; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffff0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3fbf3fbf00007fff; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000fff00000e36; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000fff0e36; ++ __m128i_out = __lsx_vssrln_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffe000ffdf; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff7fff; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffff53d9; ++ *((unsigned long *)&__m128i_op00) = 0xffff0001ffff9515; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101010101010101; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffc0800000; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000001b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fff0018; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffefffefffefffef; ++ *((unsigned long *)&__m128i_op10) = 0xffefffefffefffef; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0080000700000014; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffbffda; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3e25c8317394dae6; ++ *((unsigned long *)&__m128i_op10) = 0xcda585aebbb2836a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000ac00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x9c9c9c9c9c9c9c9c; ++ *((unsigned long *)&__m128i_op11) = 0x00000000c6c6c6c6; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c6c6c6c6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m128i_out = __lsx_vssrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssrln_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x64616462b76106dc; ++ *((unsigned long *)&__m128i_op10) = 0x64616462b71d06c2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00c0c000c0000000; ++ *((unsigned long *)&__m128i_op00) = 0xc0000000c000c000; ++ *((unsigned long *)&__m128i_op11) = 0x00c0c000c0000000; ++ *((unsigned long *)&__m128i_op10) = 0xc0000000c000c000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff7fff; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001e001e001e001e; ++ *((unsigned long *)&__m128i_op00) = 0x001e001e001e001e; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff7fff; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001700000017; ++ *((unsigned long *)&__m128i_op00) = 0x59f7fd8759f7fd87; ++ *((unsigned long *)&__m128i_op11) = 0x0000001700000017; ++ *((unsigned long *)&__m128i_op10) = 0x59f7fd8759f7fd87; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fff7fff; ++ __m128i_out = __lsx_vssrln_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffc0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff00000001; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00007fff7fff8000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000007f7f7f; ++ __m128i_out = __lsx_vssrln_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xf589caff5605f2fa; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000a74aa8a55ab; ++ *((unsigned long *)&__m128i_op00) = 0x6adeb5dfcb000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrln_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7f8000007f800000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssrln_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlni.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlni.c +new file mode 100644 +index 000000000..613668143 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlni.c +@@ -0,0 +1,668 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff80000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001ffff00000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x4f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_b_h (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004e005500060031; ++ *((unsigned long *)&__m128i_op00) = 0xff870068fff5ffb3; ++ *((unsigned long *)&__m128i_op11) = 0x004e005500060031; ++ *((unsigned long *)&__m128i_op10) = 0xff870068fff5ffb3; ++ *((unsigned long *)&__m128i_result1) = 0x04e00060ffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x04e00060ffffffff; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op00) = 0x52527d7d52527d7d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vssrlni_wu_d (__m128i_op0, __m128i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808000008080; ++ *((unsigned long *)&__m128i_op00) = 0x8080000080800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001010100010100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_wu_d (__m128i_op0, __m128i_op1, 0x2f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000080007f80800; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00047fff00007fff; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ff0000ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x01fc020000fe0100; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000003fc0003; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x56); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0c03e17edd781b11; ++ *((unsigned long *)&__m128i_op00) = 0x342caf9bffff1fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000040000000400; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0c037fff342c7fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000fff8fff8; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fff80000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_wu_d (__m128i_op0, __m128i_op1, 0x37); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffff100fffc; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff00000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x21); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffff100fffc; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffff100fffc; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffff00000000; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000800080; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x38); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffff800; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x001fffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x4b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op10) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0a000a000a000a00; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf2f2e5e5e5e5e5dc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_b_h (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000003fc0; ++ __m128i_out = __lsx_vssrlni_wu_d (__m128i_op0, __m128i_op1, 0x22); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x35); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x35); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0x10); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0008000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op11) = 0x41dfffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000083b00000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x33); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000003; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x7e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x1ff85ffe2ae5d973; ++ *((unsigned long *)&__m128i_op11) = 0x403be000ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000ffc2f; ++ *((unsigned long *)&__m128i_result0) = 0x00201df000000000; ++ __m128i_out = __lsx_vssrlni_wu_d (__m128i_op0, __m128i_op1, 0x29); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000005151515; ++ *((unsigned long *)&__m128i_op00) = 0x0000000006302e00; ++ *((unsigned long *)&__m128i_op11) = 0x000000000000003f; ++ *((unsigned long *)&__m128i_op10) = 0x7f417f417f027e03; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001fd0; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x32); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x1b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_op10) = 0xffffffbfffffffbf; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000001ffffff7f; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x5f); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000202fe02; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000101; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0x11); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x01203f1e3d1c3b1a; ++ *((unsigned long *)&__m128i_op00) = 0x3918371635143312; ++ *((unsigned long *)&__m128i_op11) = 0x21201f1e1d1c1b1a; ++ *((unsigned long *)&__m128i_op10) = 0x1918171615141312; ++ *((unsigned long *)&__m128i_result1) = 0x480f7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff7fff; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00005dcbe7e830c0; ++ *((unsigned long *)&__m128i_op11) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op10) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000001fffff59; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x63); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000007f41; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000002000; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x39); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x14ccc6320076a4d2; ++ *((unsigned long *)&__m128i_op00) = 0x685670d27e00682a; ++ *((unsigned long *)&__m128i_op11) = 0x14ccc6320076a4d2; ++ *((unsigned long *)&__m128i_op10) = 0x685670d27e00682a; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0001000100000000; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc000000fc0003fff; ++ *((unsigned long *)&__m128i_op00) = 0xbffffff0ffffc00f; ++ *((unsigned long *)&__m128i_op11) = 0x0000003f0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffc3ffff003e; ++ *((unsigned long *)&__m128i_result1) = 0x00c0000000bfffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000ffffff; ++ __m128i_out = __lsx_vssrlni_wu_d (__m128i_op0, __m128i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x800000810000807f; ++ *((unsigned long *)&__m128i_op00) = 0x808080010080007f; ++ *((unsigned long *)&__m128i_op11) = 0x800000810000807f; ++ *((unsigned long *)&__m128i_op10) = 0x808080010080007f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000020000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000000020000020; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x62); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0400400204004002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000200000002; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000002002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x6d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x2a29282726252423; ++ *((unsigned long *)&__m128i_op10) = 0x2221201f1e1d1c1b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x26); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000002002; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x2a29282726252423; ++ *((unsigned long *)&__m128i_op10) = 0x2221201f1e1d1c1b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00a8009800880078; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000807f00000000; ++ *((unsigned long *)&__m128i_op10) = 0x80006b0080808080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff00007fff7fff; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x3); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001010101; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000001fe01; ++ *((unsigned long *)&__m128i_op00) = 0x000000000001fe01; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000f0000000f; ++ *((unsigned long *)&__m128i_result0) = 0x0f0f0f0f00000000; ++ __m128i_out = __lsx_vssrlni_b_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_b_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op00) = 0x00ff010300ff0103; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x555500adfffc5cab; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0101010100000100; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03ff0101fc010102; ++ *((unsigned long *)&__m128i_op00) = 0x03fffffffc010102; ++ *((unsigned long *)&__m128i_op11) = 0x7fff010181010102; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff81010102; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x0); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x000300037ff000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0003000300a10003; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_wu_d (__m128i_op0, __m128i_op1, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000007070707; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x45); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffdfffcfffdfffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffdfffcfffdfffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x13); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000053a4f452; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000053a; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x14); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_b_h (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000b3a6000067da; ++ *((unsigned long *)&__m128i_op10) = 0x00004e420000c26a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x7a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x38); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7c7c000000007176; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x3e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000c6c7; ++ *((unsigned long *)&__m128i_op00) = 0x8d8d8d8d8d8cc6c6; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_w_d (__m128i_op0, __m128i_op1, 0x3c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000aa822a8228222; ++ *((unsigned long *)&__m128i_op00) = 0x03aa558ec8546eb6; ++ *((unsigned long *)&__m128i_op11) = 0x001a64b345308091; ++ *((unsigned long *)&__m128i_op10) = 0x001f2f2cab1c732a; ++ *((unsigned long *)&__m128i_result1) = 0x0155ffff754affff; ++ *((unsigned long *)&__m128i_result0) = 0x034cffff03e5ffff; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0xb); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc1bdceee242070dc; ++ *((unsigned long *)&__m128i_op00) = 0xe907b754d7eaa478; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_h_w (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_hu_w (__m128i_op0, __m128i_op1, 0x5); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002711350a27112; ++ *((unsigned long *)&__m128i_op00) = 0x00d5701794027113; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_du_q (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000203000010d0; ++ *((unsigned long *)&__m128i_op00) = 0xffffc00300000220; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000f50000000900; ++ *((unsigned long *)&__m128i_op00) = 0x0000090900000998; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vssrlni_d_q (__m128i_op0, __m128i_op1, 0x20); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x00000001000010f8; ++ *((unsigned long *)&__m128i_op11) = 0xfff8ffa2fffdffb0; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0f0f0f0f00000f00; ++ __m128i_out = __lsx_vssrlni_bu_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrn.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrn.c +new file mode 100644 +index 000000000..ec688bb12 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrn.c +@@ -0,0 +1,470 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000200020002; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x004200a000000000; ++ *((unsigned long *)&__m128i_op00) = 0x004200a000200001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff00007fff7fff; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000003; ++ *((unsigned long *)&__m128i_op11) = 0x00040003ff83ff84; ++ *((unsigned long *)&__m128i_op10) = 0x00040003ff4dffca; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffefffefffffffc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000002020202; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffbe6ed563; ++ *((unsigned long *)&__m128i_op11) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000008; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0100000001000100; ++ *((unsigned long *)&__m128i_op00) = 0x0100010000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff732a; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000fbf9; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op10) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000007f00000000; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op00) = 0x000a000a000a000a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000004fc04f81; ++ *((unsigned long *)&__m128i_op00) = 0x000000004fc04f80; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00007f7f00007f7f; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc1000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m128i_op11) = 0xffc1000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff000000007fff; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000bd3d00000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffff0000000ad3d; ++ *((unsigned long *)&__m128i_op10) = 0xfffff000fffff000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fff0000; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf001f0010101f002; ++ *((unsigned long *)&__m128i_op11) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_op10) = 0x1000100010001000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000dfa6e0c6; ++ *((unsigned long *)&__m128i_op00) = 0x00000000d46cdc13; ++ *((unsigned long *)&__m128i_op11) = 0xffff80df00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00007f7f00007f7f; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xfff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff3fbfffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3fbf3fbf00007fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007f7f7f01027f02; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000400000004; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffe0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x3f413f4100000000; ++ *((unsigned long *)&__m128i_op10) = 0x7f801fe000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fff7fff7fff7fff; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000010000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000100000000fc; ++ *((unsigned long *)&__m128i_op10) = 0x00000100000000fc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0100000001000000; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op00) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0c0b0a090b0a0908; ++ *((unsigned long *)&__m128i_op10) = 0x0a09080709080706; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000040a04000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000040a04000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00123fff00120012; ++ *((unsigned long *)&__m128i_op00) = 0x0012001200120012; ++ *((unsigned long *)&__m128i_op11) = 0x00003fff00010000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1200091212121212; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_b_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0800010001ff8000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x2e9028362e902836; ++ *((unsigned long *)&__m128i_op10) = 0x2e9028362e902836; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_h_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001000000010; ++ __m128i_out = __lsx_vssrlrn_wu_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x33f5c2d7d975d7fe; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000084d12ce; ++ *((unsigned long *)&__m128i_op10) = 0x0000000024170000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrn_w_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0002711350a27112; ++ *((unsigned long *)&__m128i_op10) = 0x00d5701794027113; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x4399d3221a29d3f2; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0674c886fcba4e98; ++ *((unsigned long *)&__m128i_op10) = 0xfdce8003090b0906; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffff001a00000000; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001000000010; ++ __m128i_out = __lsx_vssrlrn_hu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001fffe00014b41; ++ *((unsigned long *)&__m128i_op00) = 0x0001fffe0001ffde; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0002000100020002; ++ __m128i_out = __lsx_vssrlrn_bu_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrni.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrni.c +new file mode 100644 +index 000000000..02f7ca08b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vssrlrni.c +@@ -0,0 +1,597 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x3d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x8080808000008080; ++ *((unsigned long *)&__m128i_result0) = 0x8080000080800000; ++ __m128i_out = __lsx_vssrlrni_bu_h (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000080000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000080000000; ++ __m128i_out = __lsx_vssrlrni_wu_d (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000017fff9000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000210011084; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_bu_h (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000007f0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001000100000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000007f00; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000000; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x8); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010400100203; ++ *((unsigned long *)&__m128i_op00) = 0x0103010301020109; ++ *((unsigned long *)&__m128i_op11) = 0x0000000110000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000007f00000004; ++ *((unsigned long *)&__m128i_result1) = 0x0202000402020202; ++ *((unsigned long *)&__m128i_result0) = 0x0000200000010000; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x56); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x6d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0001ffff8002; ++ *((unsigned long *)&__m128i_op00) = 0x0010000400020004; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffff20ff; ++ *((unsigned long *)&__m128i_op10) = 0xfffc0020ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x07fff80000008000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000007ffe001; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_d_q (__m128i_op0, __m128i_op1, 0x7c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x03574e3b94f2ca31; ++ *((unsigned long *)&__m128i_op00) = 0x000000001f807b89; ++ *((unsigned long *)&__m128i_op11) = 0x0000000005050000; ++ *((unsigned long *)&__m128i_op10) = 0x0505000005050505; ++ *((unsigned long *)&__m128i_result1) = 0x000d02540000007e; ++ *((unsigned long *)&__m128i_result0) = 0x0000001400140014; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x41); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x3b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op11) = 0x56a09e662ab46b31; ++ *((unsigned long *)&__m128i_op10) = 0xb4b8122ef4054bb3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x02b504f305a5c091; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x37); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000d000d000d000d; ++ *((unsigned long *)&__m128i_op00) = 0x000d000d000d000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000680000006800; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x25); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000400; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0xe); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00005555aaabfffe; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x003fffffff000000; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000000ab; ++ *((unsigned long *)&__m128i_result0) = 0x00000000000000ff; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x43); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fff7fff; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fff7fff; ++ *((unsigned long *)&__m128i_op11) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000080; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrni_wu_d (__m128i_op0, __m128i_op1, 0x18); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000080000000000; ++ __m128i_out = __lsx_vssrlrni_wu_d (__m128i_op0, __m128i_op1, 0x34); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x027c027c000027c0; ++ *((unsigned long *)&__m128i_op11) = 0x000000004f804f81; ++ *((unsigned long *)&__m128i_op10) = 0x000000004f804f80; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000010000; ++ *((unsigned long *)&__m128i_result0) = 0x0000001400000014; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x1a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ff81007c; ++ *((unsigned long *)&__m128i_op00) = 0xffb7005f0070007c; ++ *((unsigned long *)&__m128i_op11) = 0xffff80007e028401; ++ *((unsigned long *)&__m128i_op10) = 0x9a10144000400000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0000001ffff00010; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x5b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_wu_d (__m128i_op0, __m128i_op1, 0x29); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000040000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000080000000000; ++ __m128i_out = __lsx_vssrlrni_hu_w (__m128i_op0, __m128i_op1, 0x7); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffff9cff05; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff9cfebd; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000002; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op11) = 0xff7ffffef77fffdd; ++ *((unsigned long *)&__m128i_op10) = 0xf77edf9cffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001fffff001fffff; ++ *((unsigned long *)&__m128i_op00) = 0x001fffff001fffff; ++ *((unsigned long *)&__m128i_op11) = 0x21201f1e1d1c1b1a; ++ *((unsigned long *)&__m128i_op10) = 0x1918171615141312; ++ *((unsigned long *)&__m128i_result1) = 0x10ff10ff10ff10ff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrni_bu_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffa6ff91fdd8ef77; ++ *((unsigned long *)&__m128i_op00) = 0x061202bffb141c38; ++ *((unsigned long *)&__m128i_op11) = 0x0101010101010101; ++ *((unsigned long *)&__m128i_op10) = 0x010101fe0101fe87; ++ *((unsigned long *)&__m128i_result1) = 0x0000004000000002; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_wu_d (__m128i_op0, __m128i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffd60001723aa5f8; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000007f007f7f; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f7f7f7f7f7f7f; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x808080e280808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080636380806363; ++ *((unsigned long *)&__m128i_op11) = 0x808080e280808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080636380806363; ++ *((unsigned long *)&__m128i_result1) = 0x0004000400040004; ++ *((unsigned long *)&__m128i_result0) = 0x0004000400040004; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x1d); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000d0000000d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000dffff000d; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000070007; ++ *((unsigned long *)&__m128i_result0) = 0x000000000007ffff; ++ __m128i_out = __lsx_vssrlrni_hu_w (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000800c00000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000800000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_hu_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000007fff7fff; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x9); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffff0100ff; ++ *((unsigned long *)&__m128i_op11) = 0x0607060700000807; ++ *((unsigned long *)&__m128i_op10) = 0x0707f8f803e8157e; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x31); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x21); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0xc); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op00) = 0x5252525252525252; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_bu_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc0808000c0808000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000003020302; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x16); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffc0ff80ff800000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_wu_d (__m128i_op0, __m128i_op1, 0x15); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff0000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffff000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_bu_h (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_bu_h (__m128i_op0, __m128i_op1, 0x4); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ffffffe00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x3a); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffc0800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000008080600; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_op00) = 0x52525252adadadad; ++ *((unsigned long *)&__m128i_op11) = 0x800000007fffffff; ++ *((unsigned long *)&__m128i_op10) = 0x800000007fffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffffffffff; ++ __m128i_out = __lsx_vssrlrni_hu_w (__m128i_op0, __m128i_op1, 0x6); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003ef89df07f0000; ++ *((unsigned long *)&__m128i_op00) = 0x003ec0fc0fbfe001; ++ *((unsigned long *)&__m128i_op11) = 0x3ff800ff2fe6c00d; ++ *((unsigned long *)&__m128i_op10) = 0xfff40408ece0e0de; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0xa); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4000400040004000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x12); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ff960001005b; ++ *((unsigned long *)&__m128i_op00) = 0x0000ffa500010003; ++ *((unsigned long *)&__m128i_op11) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_result0) = 0x0020000000000000; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x2b); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x1748c4f9ed1a5870; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffffffffffff; ++ __m128i_out = __lsx_vssrlrni_d_q (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff7ffffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x00000000fffffffe; ++ *((unsigned long *)&__m128i_op11) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_op10) = 0xfcfcfcdcfcfcfcdc; ++ *((unsigned long *)&__m128i_result1) = 0x0010001000000010; ++ *((unsigned long *)&__m128i_result0) = 0x0010001000100010; ++ __m128i_out = __lsx_vssrlrni_hu_w (__m128i_op0, __m128i_op1, 0x1c); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000020; ++ *((unsigned long *)&__m128i_op00) = 0x0000001f0000001f; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x4000000040000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x27); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0x28); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_du_q (__m128i_op0, __m128i_op1, 0x26); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x117d7f7b093d187f; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000034; ++ *((unsigned long *)&__m128i_op11) = 0xfe1bfefe00011ee1; ++ *((unsigned long *)&__m128i_op10) = 0xfe1bfe6c03824c60; ++ *((unsigned long *)&__m128i_result1) = 0x7f7f7f7f0000001a; ++ *((unsigned long *)&__m128i_result0) = 0x7f7f017f7f7f7f7f; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0x1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffff3a81ffff89fd; ++ *((unsigned long *)&__m128i_op10) = 0xffffb3c3ffff51ba; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0802080408060803; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0xd); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffff00ffffff00ff; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op10) = 0x00ff000900ffff98; ++ *((unsigned long *)&__m128i_result1) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_result0) = 0x7fffffff7fffffff; ++ __m128i_out = __lsx_vssrlrni_w_d (__m128i_op0, __m128i_op1, 0xf); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0xc); ++ *((unsigned long *)&__m128i_op01) = 0x0000000056000056; ++ *((unsigned long *)&__m128i_op00) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000efffefff; ++ *((unsigned long *)&__m128i_op10) = 0xa03aa03ae3e2e3e2; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_d_q (__m128i_op0, __m128i_op1, 0x75); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000760151; ++ *((unsigned long *)&__m128i_op00) = 0x003e0021009a009a; ++ *((unsigned long *)&__m128i_op11) = 0x00000000246d9755; ++ *((unsigned long *)&__m128i_op10) = 0x0000003e2427c2ee; ++ *((unsigned long *)&__m128i_result1) = 0x00001e5410082727; ++ *((unsigned long *)&__m128i_result0) = 0x00007f7f00107f7f; ++ __m128i_out = __lsx_vssrlrni_b_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000000f1384; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000004ff; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ffffffff; ++ __m128i_out = __lsx_vssrlrni_bu_h (__m128i_op0, __m128i_op1, 0x2); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x10f8000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vssrlrni_h_w (__m128i_op0, __m128i_op1, 0x1e); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-for-the-SX-vector-multiplication.patch
Added
@@ -0,0 +1,2990 @@ +From 239d4bdbbc72f83efba3830203443b0b2ba4f2ca Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 10:15:12 +0800 +Subject: PATCH 083/124 LoongArch: Add tests for the SX vector multiplication + instruction. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/lsx/lsx-vmuh-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmuh-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmul.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmulwev-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmulwev-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmulwev-3.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmulwod-1.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmulwod-2.c: New test. + * gcc.target/loongarch/vector/lsx/lsx-vmulwod-3.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/lsx/lsx-vmuh-1.c | 353 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vmuh-2.c | 372 +++++++++++++++ + .../loongarch/vector/lsx/lsx-vmul.c | 282 ++++++++++++ + .../loongarch/vector/lsx/lsx-vmulwev-1.c | 434 ++++++++++++++++++ + .../loongarch/vector/lsx/lsx-vmulwev-2.c | 344 ++++++++++++++ + .../loongarch/vector/lsx/lsx-vmulwev-3.c | 245 ++++++++++ + .../loongarch/vector/lsx/lsx-vmulwod-1.c | 272 +++++++++++ + .../loongarch/vector/lsx/lsx-vmulwod-2.c | 282 ++++++++++++ + .../loongarch/vector/lsx/lsx-vmulwod-3.c | 308 +++++++++++++ + 9 files changed, 2892 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmul.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-3.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-1.c +new file mode 100644 +index 000000000..ab650a024 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-1.c +@@ -0,0 +1,353 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x059a35ef139a8e00; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op00) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op11) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_op10) = 0x8080808080808080; ++ *((unsigned long *)&__m128i_result1) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_result0) = 0x4040404040404040; ++ __m128i_out = __lsx_vmuh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xc0c00000c0c00000; ++ *((unsigned long *)&__m128i_op10) = 0xc0c00c01c2cd0009; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc0fffff000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffe00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff0000ac26; ++ *((unsigned long *)&__m128i_op10) = 0x00ff000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ffffff81fe; ++ *((unsigned long *)&__m128i_op00) = 0xffffff00ffff7e01; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000fffe01fd02; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ffff0000fe86; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m128i_op10) = 0x7f7f7f7f7f7f7f7f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xff8000010f800000; ++ *((unsigned long *)&__m128i_op11) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_op10) = 0xff800000ff800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fff80000; ++ __m128i_out = __lsx_vmuh_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xbf3efff536d5169b; ++ *((unsigned long *)&__m128i_op00) = 0x7ebdfffffddf3f40; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3f5ec0a0feefa0b0; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffff7ffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x3fffffff3ffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x3fffffff3ffffffe; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x003f0000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7fff0101ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffffa0204000; ++ *((unsigned long *)&__m128i_result1) = 0x001f7fc100000000; ++ *((unsigned long *)&__m128i_result0) = 0x001f7fff00000000; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000000010000; ++ *((unsigned long *)&__m128i_op00) = 0x0000cd630000cd63; ++ *((unsigned long *)&__m128i_op11) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_op10) = 0xcd636363cd636363; ++ *((unsigned long *)&__m128i_result1) = 0xffffcd63ffffcd63; ++ *((unsigned long *)&__m128i_result0) = 0xffffd765ffffd765; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xff7fffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0040000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000015516a768038; ++ *((unsigned long *)&__m128i_op00) = 0xffffff9ed2e1c000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x007ffd0001400840; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x007ffd0001400840; ++ *((unsigned long *)&__m128i_result1) = 0x3fffffff80000000; ++ *((unsigned long *)&__m128i_result0) = 0x00003ffd000a4000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0032000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0032000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000009c400000000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0002000200020002; ++ *((unsigned long *)&__m128i_op00) = 0x0202fe02fd020102; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000202fe02; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000006362ffff; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffff0000ffff0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fffe0002; ++ __m128i_out = __lsx_vmuh_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-2.c +new file mode 100644 +index 000000000..60b6e3503 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmuh-2.c +@@ -0,0 +1,372 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000011; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000c5ac01015b; ++ *((unsigned long *)&__m128i_op00) = 0xaaacac88a3a9a96a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_op10) = 0x0000001300000013; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000038003; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000040033; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000080000068; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000014; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x8000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x10f881a20ffd02b0; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ff800000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0ff780a10efc01af; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fe7f0000; ++ __m128i_out = __lsx_vmuh_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000efffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001001100110068; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x1d8000001d800000; ++ *((unsigned long *)&__m128i_op00) = 0x1d8000001d800000; ++ *((unsigned long *)&__m128i_op11) = 0x1d8000001d800000; ++ *((unsigned long *)&__m128i_op10) = 0x1d8000001d800000; ++ *((unsigned long *)&__m128i_result1) = 0x0366000003660000; ++ *((unsigned long *)&__m128i_result0) = 0x0366000003660000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_op10) = 0xc5c534920000c4ed; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000800; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ef400ad21fc7081; ++ *((unsigned long *)&__m128i_op00) = 0x28bf0351ec69b5f2; ++ *((unsigned long *)&__m128i_op11) = 0xffffb96bffff57c9; ++ *((unsigned long *)&__m128i_op10) = 0xffff6080ffff4417; ++ *((unsigned long *)&__m128i_result1) = 0x7ef3ddac21fc5a2c; ++ *((unsigned long *)&__m128i_result0) = 0x28bee9edec690869; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ int_out = __lsx_vpickve2gr_h (__m128i_op0, 0x0); ++ *((unsigned long *)&__m128i_op01) = 0x0000200000002000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffe000ffdf; ++ *((unsigned long *)&__m128i_result1) = 0x00001fff00001fff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000800000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000214f; ++ *((unsigned long *)&__m128i_op00) = 0xc31b63d846ebc810; ++ *((unsigned long *)&__m128i_op11) = 0x00ff0000800000ff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffff941d; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000010a7; ++ *((unsigned long *)&__m128i_result0) = 0x0000000046ebaa2c; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000cf4f4f00; ++ *((unsigned long *)&__m128i_op10) = 0x00000000cf4f4f00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000007c; ++ *((unsigned long *)&__m128i_op00) = 0x0000005f0003e000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000897957687; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000408; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000003397dd140; ++ *((unsigned long *)&__m128i_op00) = 0x00000004bd7cdd20; ++ *((unsigned long *)&__m128i_op11) = 0x0016ffb00016ffb0; ++ *((unsigned long *)&__m128i_op10) = 0x0016ffb00016ffb0; ++ *((unsigned long *)&__m128i_result1) = 0x00000000004a294b; ++ *((unsigned long *)&__m128i_result0) = 0x00000000006d04bc; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op00) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x007ffe7ffe400000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x007ffd0001400840; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffcfffcfffcfffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffffffffe; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffa800000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000157; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001a64b345308091; ++ *((unsigned long *)&__m128i_op00) = 0x001f2f2cab1c732a; ++ *((unsigned long *)&__m128i_op11) = 0x1baf8eabd26bc629; ++ *((unsigned long *)&__m128i_op10) = 0x1c2640b9a8e9fb49; ++ *((unsigned long *)&__m128i_result1) = 0x0002dab8746acf8e; ++ *((unsigned long *)&__m128i_result0) = 0x00036dd1c5c15856; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x00003a7fc58074ff; ++ *((unsigned long *)&__m128i_result0) = 0x0000000eeff1100e; ++ __m128i_out = __lsx_vmuh_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmul.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmul.c +new file mode 100644 +index 000000000..8ba666275 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmul.c +@@ -0,0 +1,282 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x54feed87bc3f2be1; ++ *((unsigned long *)&__m128i_op00) = 0x8064d8f6a494afcb; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op10) = 0x1e801ffc7fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffffe003c1f0077; ++ *((unsigned long *)&__m128i_op00) = 0xffffff0074230438; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000ff0000000438; ++ __m128i_out = __lsx_vmul_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_bu (__m128i_op0, 0x2); ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000800800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000800800000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000004000000000; ++ __m128i_out = __lsx_vmul_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfff5fff4002ffff5; ++ *((unsigned long *)&__m128i_op11) = 0xaa858644fb8b3d49; ++ *((unsigned long *)&__m128i_op10) = 0x18499e2cee2cc251; ++ *((unsigned long *)&__m128i_result1) = 0x8644000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xaed495f03343a685; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7505443065413aed; ++ *((unsigned long *)&__m128i_op00) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_op11) = 0x7505443065413aed; ++ *((unsigned long *)&__m128i_op10) = 0x0100d6effefd0498; ++ *((unsigned long *)&__m128i_result1) = 0xb71289fdfbea3f69; ++ *((unsigned long *)&__m128i_result0) = 0x4e17c2ffb4851a40; ++ __m128i_out = __lsx_vmul_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfc01fcfefc02fdf7; ++ *((unsigned long *)&__m128i_op00) = 0xfe00fcfffe01fd01; ++ *((unsigned long *)&__m128i_op11) = 0xfc01fd1300000001; ++ *((unsigned long *)&__m128i_op10) = 0xfe00fd1400010000; ++ *((unsigned long *)&__m128i_result1) = 0xc72ef153fc02fdf7; ++ *((unsigned long *)&__m128i_result0) = 0xca31bf15fd010000; ++ __m128i_out = __lsx_vmul_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000100000001; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op00) = 0xff00ff00ff00ff00; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xc000c000c000ff81; ++ *((unsigned long *)&__m128i_op11) = 0x5d5d5d5d5d5d5d5d; ++ *((unsigned long *)&__m128i_op10) = 0x5d5d5d5d5d5d0000; ++ *((unsigned long *)&__m128i_result1) = 0xa2a2a2a3a2a2a2a3; ++ *((unsigned long *)&__m128i_result0) = 0xc605c000aedd0000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xacc8c794af2caf01; ++ *((unsigned long *)&__m128i_op00) = 0xa91e2048938c40f0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xeeb1e4f43c3763f3; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff5a6fe3d7; ++ *((unsigned long *)&__m128i_op11) = 0x0000000021e79364; ++ *((unsigned long *)&__m128i_op10) = 0x0000718ea657431b; ++ *((unsigned long *)&__m128i_result1) = 0x000000006ca193ec; ++ *((unsigned long *)&__m128i_result0) = 0x00008e72b5b94cad; ++ __m128i_out = __lsx_vmul_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffe000ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x467f6080467d607f; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000001000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000001000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x007f008000ea007f; ++ *((unsigned long *)&__m128i_op00) = 0x00ff00ff00ff00ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xc000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0042003e0042002f; ++ *((unsigned long *)&__m128i_op00) = 0x0001fffc0001fffc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffe0004fffe0004; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc1bdceee242070db; ++ *((unsigned long *)&__m128i_op00) = 0xe8c7b756d76aa478; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3f433212dce09025; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf359f359f359f359; ++ *((unsigned long *)&__m128i_op00) = 0xf359f359f359f359; ++ *((unsigned long *)&__m128i_op11) = 0xd3259a2984048c23; ++ *((unsigned long *)&__m128i_op10) = 0xf9796558e39953fd; ++ *((unsigned long *)&__m128i_result1) = 0x86dd8341b164f12b; ++ *((unsigned long *)&__m128i_result0) = 0x9611c3985b3159f5; ++ __m128i_out = __lsx_vmul_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op00) = 0xffd27db010d20fbf; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0xffd27db010d20fbf; ++ *((unsigned long *)&__m128i_result1) = 0x9727b8499727b849; ++ *((unsigned long *)&__m128i_result0) = 0x12755900b653f081; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_op00) = 0x0303030303030303; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x02f3030303030303; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x06d9090909090909; ++ __m128i_out = __lsx_vmul_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff81ffff7f03; ++ *((unsigned long *)&__m128i_op00) = 0x04ffff8101ff81ff; ++ *((unsigned long *)&__m128i_op11) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_op10) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_result1) = 0x0a0000001e000000; ++ *((unsigned long *)&__m128i_result0) = 0x0a000000f6000000; ++ __m128i_out = __lsx_vmul_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x317fce80317fce80; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmul_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-1.c +new file mode 100644 +index 000000000..8357f4e80 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-1.c +@@ -0,0 +1,434 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000158; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x001f7fc100000404; ++ *((unsigned long *)&__m128i_op00) = 0x000000000002a000; ++ *((unsigned long *)&__m128i_op11) = 0x7fff0101ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x7fffffffa0204000; ++ *((unsigned long *)&__m128i_result1) = 0xffe1ffc100000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000400000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000009000900; ++ *((unsigned long *)&__m128i_op00) = 0x0000000009000900; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x30eb022002101b20; ++ *((unsigned long *)&__m128i_op00) = 0x020310edc003023d; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000ffc3; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_op10) = 0x6363636363636363; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xff9dff9dff9dff9d; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000efffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffe50000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000ff0000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffe020; ++ *((unsigned long *)&__m128i_op10) = 0x3fc00000010a000b; ++ *((unsigned long *)&__m128i_result1) = 0x00001b0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ff81007c; ++ *((unsigned long *)&__m128i_op00) = 0xffb7005f0070007c; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000104000800; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000007c; ++ *((unsigned long *)&__m128i_result0) = 0x0000005f0003e000; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_op10) = 0x4040404040404040; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xffffbfc0ffffbfc0; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x000000ffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x000000ffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffff0100000001; ++ *((unsigned long *)&__m128i_result0) = 0xffffff0100000001; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_op10) = 0x0000208000002080; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000004870ba0; ++ *((unsigned long *)&__m128i_op11) = 0x478b478b38031779; ++ *((unsigned long *)&__m128i_op10) = 0x6b769e690fa1e119; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fe98c2a0; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000004000000040; ++ *((unsigned long *)&__m128i_op00) = 0x00007770ffff9411; ++ *((unsigned long *)&__m128i_op11) = 0x0000004000000040; ++ *((unsigned long *)&__m128i_op10) = 0x00007770ffff9411; ++ *((unsigned long *)&__m128i_result1) = 0x0000100000001000; ++ *((unsigned long *)&__m128i_result0) = 0x37b951002d81a921; ++ __m128i_out = __lsx_vmulwev_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000e0000000e0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000e0000000e0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000c400; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x000000ffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff80000001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000016; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffb4ff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffffffff98dea; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0006000000040000; ++ *((unsigned long *)&__m128i_op00) = 0x0002000000000007; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000f80007; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000006c80031; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000101010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001010001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000010001; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000202020200; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op11) = 0x0808080808080808; ++ *((unsigned long *)&__m128i_op10) = 0x0004280808080808; ++ *((unsigned long *)&__m128i_result1) = 0x0010203030201000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000808080800; ++ __m128i_out = __lsx_vmulwev_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000b5207f80; ++ *((unsigned long *)&__m128i_op11) = 0x2000000020000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000200200000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0x6a57a30ff0000000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffff7; ++ *((unsigned long *)&__m128i_op11) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0xfffffff700000009; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000104000800; ++ *((unsigned long *)&__m128i_op11) = 0x8001000180010001; ++ *((unsigned long *)&__m128i_op10) = 0x8001000184000800; ++ *((unsigned long *)&__m128i_result1) = 0xffff80007e028401; ++ *((unsigned long *)&__m128i_result0) = 0x9a10144000400000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000bd003d; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000fffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0010000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000077af9450; ++ *((unsigned long *)&__m128i_op11) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_op10) = 0x000047404f4f040d; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000214f; ++ *((unsigned long *)&__m128i_result0) = 0xc31b63d846ebc810; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000002000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-2.c +new file mode 100644 +index 000000000..e4afc8247 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-2.c +@@ -0,0 +1,344 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xfe01fe01fe01fe01; ++ *((unsigned long *)&__m128i_result0) = 0x00000000fe01fe01; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000200020; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op00) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op11) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_op10) = 0x8000000080000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x6a5d5b056f2f4978; ++ *((unsigned long *)&__m128i_op00) = 0x17483c07141b5971; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xd4bade5e2e902836; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x345002920f3017d6; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000c0010000a186; ++ *((unsigned long *)&__m128i_op00) = 0x00067fff0002a207; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffff0002; ++ *((unsigned long *)&__m128i_result1) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_result0) = 0x05fafe0101fe000e; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100000001; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0xc1f03e1042208410; ++ *((unsigned long *)&__m128i_result1) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_result0) = 0x00f0001000000010; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000000eefff; ++ *((unsigned long *)&__m128i_op00) = 0xf8e1a03affffe3e2; ++ *((unsigned long *)&__m128i_op11) = 0x3a80613fda5dcb4a; ++ *((unsigned long *)&__m128i_op10) = 0x93f0b81a914c003b; ++ *((unsigned long *)&__m128i_result1) = 0x00000000051649b6; ++ *((unsigned long *)&__m128i_result0) = 0xd2f005e44bb43416; ++ __m128i_out = __lsx_vmulwev_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001fc0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fffffff7fffffff; ++ *((unsigned long *)&__m128i_op00) = 0x7fffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000200000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0001fffe00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x00000001fffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffff000f0008d3c; ++ *((unsigned long *)&__m128i_op00) = 0xfffff0016fff8d3d; ++ *((unsigned long *)&__m128i_op11) = 0xfffff000f0008d3c; ++ *((unsigned long *)&__m128i_op10) = 0xfffff0016fff8d3d; ++ *((unsigned long *)&__m128i_result1) = 0xe10000004deb2610; ++ *((unsigned long *)&__m128i_result0) = 0xe101e0014dec4089; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x111110ff11111141; ++ *((unsigned long *)&__m128i_op10) = 0x11111131111116a6; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x2028000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001001100110068; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0xd400c02000002acf; ++ *((unsigned long *)&__m128i_op10) = 0xf4000020c4000000; ++ *((unsigned long *)&__m128i_result1) = 0x6453f5e01d6e5000; ++ *((unsigned long *)&__m128i_result0) = 0x000fdec000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xbfd10d0d7b6b6b73; ++ *((unsigned long *)&__m128i_op10) = 0xc5c534920000c4ed; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001700000017; ++ *((unsigned long *)&__m128i_op00) = 0x59f7fd8759f7fd87; ++ *((unsigned long *)&__m128i_op11) = 0x0000001700000017; ++ *((unsigned long *)&__m128i_op10) = 0x59f7fd8759f7fd87; ++ *((unsigned long *)&__m128i_result1) = 0x0000021100000211; ++ *((unsigned long *)&__m128i_result0) = 0xfb141d31fb141d31; ++ __m128i_out = __lsx_vmulwev_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x7f800000976801fe; ++ *((unsigned long *)&__m128i_op10) = 0x837c1ae57f8012ed; ++ *((unsigned long *)&__m128i_result1) = 0x976801fd6897fe02; ++ *((unsigned long *)&__m128i_result0) = 0x7f8012ec807fed13; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000008000000080; ++ *((unsigned long *)&__m128i_op00) = 0x0080000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op10) = 0x000100010001fffe; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000800080; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0002ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff8000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0909090900000909; ++ *((unsigned long *)&__m128i_op10) = 0x0909090909090909; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000100; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a80613fda5dcb4a; ++ *((unsigned long *)&__m128i_op00) = 0x93f0b81a914c003b; ++ *((unsigned long *)&__m128i_op11) = 0x0000feff23560000; ++ *((unsigned long *)&__m128i_op10) = 0x0000fd1654860000; ++ *((unsigned long *)&__m128i_result1) = 0x1e242e4d68dc0000; ++ *((unsigned long *)&__m128i_result0) = 0x2ff8fddb7ae20000; ++ __m128i_out = __lsx_vmulwev_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000060000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000060000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff000ff6220c0c1; ++ *((unsigned long *)&__m128i_op00) = 0xffe8081000000000; ++ *((unsigned long *)&__m128i_op11) = 0x000000007ff000ff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-3.c +new file mode 100644 +index 000000000..346f0316a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwev-3.c +@@ -0,0 +1,245 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000017fda829; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0xff01ff01ff01ff01; ++ *((unsigned long *)&__m128i_result0) = 0xff01ff01ff01fc10; ++ __m128i_out = __lsx_vmulwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0042003e0042002f; ++ *((unsigned long *)&__m128i_op00) = 0x0001fffc0001fffc; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0xffbeffc2ffbeffd1; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000003f80; ++ *((unsigned long *)&__m128i_op11) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op00) = 0x80000000fff80000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op10) = 0x80000000fff80000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000004000; ++ *((unsigned long *)&__m128i_result0) = 0xfff8004000000000; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffff8607db959f; ++ *((unsigned long *)&__m128i_op00) = 0xff0cff78ff96ff14; ++ *((unsigned long *)&__m128i_op11) = 0x0000008a0000008a; ++ *((unsigned long *)&__m128i_op10) = 0x0000008900000009; ++ *((unsigned long *)&__m128i_result1) = 0x000000043c5ea7b6; ++ *((unsigned long *)&__m128i_result0) = 0x00000008fc4ef7b4; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffff46; ++ *((unsigned long *)&__m128i_result1) = 0xfffffffe00000002; ++ *((unsigned long *)&__m128i_result0) = 0xffffff46000000ba; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffc; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf8f8372f752402ee; ++ *((unsigned long *)&__m128i_op11) = 0x7fffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffc0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000100000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x80044def00000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ff000000ff00; ++ *((unsigned long *)&__m128i_result1) = 0x00007f8449a19084; ++ *((unsigned long *)&__m128i_result0) = 0x49a210000000ff00; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfffcfd000000fb00; ++ *((unsigned long *)&__m128i_op00) = 0x0001fe00f8000700; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0xfdfef9ff0efff900; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7efefefe82010201; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result0) = 0x7afafaf88a050a05; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xcda585aebbb2836a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xcda585aebbb2836a; ++ *((unsigned long *)&__m128i_result1) = 0xd78cfd70b5f65d76; ++ *((unsigned long *)&__m128i_result0) = 0x5779108fdedda7e4; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op00) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_op11) = 0x67eb85afb2ebb000; ++ *((unsigned long *)&__m128i_op10) = 0xc8847ef6ed3f2000; ++ *((unsigned long *)&__m128i_result1) = 0xd48acbfe13102acf; ++ *((unsigned long *)&__m128i_result0) = 0xf4af70d0c4000000; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffe0000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op00) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000056; ++ *((unsigned long *)&__m128i_op10) = 0x00000000ffffff86; ++ *((unsigned long *)&__m128i_result1) = 0x00000000000eefff; ++ *((unsigned long *)&__m128i_result0) = 0xf8e1a03affffe3e2; ++ __m128i_out = __lsx_vmulwev_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-1.c +new file mode 100644 +index 000000000..6eea49a61 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-1.c +@@ -0,0 +1,272 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000006; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0100010000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0100010000010000; ++ *((unsigned long *)&__m128i_result1) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000003ddc5dac; ++ *((unsigned long *)&__m128i_op11) = 0x67157b5100005000; ++ *((unsigned long *)&__m128i_op10) = 0x387c7e0a133f2000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000004870ba0; ++ __m128i_out = __lsx_vmulwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfefe000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff000000000155; ++ *((unsigned long *)&__m128i_op11) = 0x0000000100000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffff8001ffff8001; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x7ff0000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x3ff0010000000000; ++ *((unsigned long *)&__m128i_result0) = 0x3ff0010000000000; ++ __m128i_out = __lsx_vmulwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00009c7c00007176; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x440ef000440ef000; ++ *((unsigned long *)&__m128i_op00) = 0x4400000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3a8000003a800000; ++ *((unsigned long *)&__m128i_op10) = 0x000ef0000000003b; ++ *((unsigned long *)&__m128i_result1) = 0x0f8d33000f8d3300; ++ *((unsigned long *)&__m128i_result0) = 0x0003b80000000000; ++ __m128i_out = __lsx_vmulwod_w_h (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0018001800180018; ++ *((unsigned long *)&__m128i_op00) = 0x0018001800180018; ++ *((unsigned long *)&__m128i_op11) = 0x85bd6b0e94d89998; ++ *((unsigned long *)&__m128i_op10) = 0xd83c8081ffff808f; ++ *((unsigned long *)&__m128i_result1) = 0xfff489b693120950; ++ *((unsigned long *)&__m128i_result0) = 0xfffc45a851c40c18; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffe5; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000001; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3e1f321529232736; ++ *((unsigned long *)&__m128i_op10) = 0x161d0c373c200826; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op00) = 0x3f8000003f800000; ++ *((unsigned long *)&__m128i_op11) = 0x0001000000010001; ++ *((unsigned long *)&__m128i_op10) = 0x0001000000010001; ++ *((unsigned long *)&__m128i_result1) = 0x00003f8000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00003f8000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x7fff000000007fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffffffdfffdf; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffe000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c6fde000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000fef01000f27ca; ++ *((unsigned long *)&__m128i_op11) = 0x0000010000010101; ++ *((unsigned long *)&__m128i_op10) = 0x0101000001000100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000ffef0010000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x00000000ffffffe0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000005452505; ++ *((unsigned long *)&__m128i_op10) = 0x000000044525043c; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x3fc03fc000000004; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result0) = 0xffffffffc03fc040; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000000a; ++ *((unsigned long *)&__m128i_op00) = 0x000000000000000a; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00fe000100cf005f; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff7fff7f00; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000400028000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000004; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xc110000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xc00d060000000000; ++ *((unsigned long *)&__m128i_op11) = 0x3ff0000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x40f3fa0000000000; ++ *((unsigned long *)&__m128i_result1) = 0xf047ef0000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00007fff7fff8000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffff100000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000f0000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-2.c +new file mode 100644 +index 000000000..f3e4e0390 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-2.c +@@ -0,0 +1,282 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x004e005500060031; ++ *((unsigned long *)&__m128i_op10) = 0xff870068fff5ffb3; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000200010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xfa31dfa21672e711; ++ *((unsigned long *)&__m128i_op00) = 0x1304db85e468073a; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000150000; ++ *((unsigned long *)&__m128i_op00) = 0xfffeffff001effff; ++ *((unsigned long *)&__m128i_op11) = 0x00000000ffffffff; ++ *((unsigned long *)&__m128i_op10) = 0x00000000fffff1a0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x000000000000f00f; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000080; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ unsigned_int_out = __lsx_vpickve2gr_hu (__m128i_op0, 0x4); ++ *((unsigned long *)&__m128i_op01) = 0xe2560afe9c001a18; ++ *((unsigned long *)&__m128i_op00) = 0xe2560afe9c001a18; ++ *((unsigned long *)&__m128i_op11) = 0x000000ff0000857a; ++ *((unsigned long *)&__m128i_op10) = 0x05fafe0101fe000e; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000d82; ++ *((unsigned long *)&__m128i_result0) = 0x046a09ec009c0000; ++ __m128i_out = __lsx_vmulwod_h_bu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfe80ffffffffff02; ++ *((unsigned long *)&__m128i_op11) = 0x7fff7fff7fff7fff; ++ *((unsigned long *)&__m128i_op10) = 0x7fff7fff00000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x7f3f018000000000; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf0fd800080000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000a00028004000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000005a00000228; ++ *((unsigned long *)&__m128i_op00) = 0xfffff9ee000004ec; ++ *((unsigned long *)&__m128i_op11) = 0xfffffacdb6dbecac; ++ *((unsigned long *)&__m128i_op10) = 0x1f5533a694f902c0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x1f54e0ab00000000; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00e4880080000000; ++ *((unsigned long *)&__m128i_op10) = 0x0080810080808100; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xff011fb11181d8ea; ++ *((unsigned long *)&__m128i_op00) = 0x80ff800000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00fe00fe000200fe; ++ *((unsigned long *)&__m128i_op10) = 0x00fe00fe000200fe; ++ *((unsigned long *)&__m128i_result1) = 0x00fd02fe00002302; ++ *((unsigned long *)&__m128i_result0) = 0x007ffd0200000000; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0xfffe0001fffe0001; ++ __m128i_out = __lsx_vmulwod_w_hu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x14ccc6320076a4d2; ++ *((unsigned long *)&__m128i_op00) = 0x685670d27e00682a; ++ *((unsigned long *)&__m128i_op11) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_op10) = 0xfffffffffffffffe; ++ *((unsigned long *)&__m128i_result1) = 0x14ccc631eb3339ce; ++ *((unsigned long *)&__m128i_result0) = 0x685670d197a98f2e; ++ __m128i_out = __lsx_vmulwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xf000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffc0ffc0003f; ++ *((unsigned long *)&__m128i_op00) = 0xffc0ffc0003f003f; ++ *((unsigned long *)&__m128i_op11) = 0x000000400000004c; ++ *((unsigned long *)&__m128i_op10) = 0x00007770ffff941d; ++ *((unsigned long *)&__m128i_result1) = 0x000000000ffff000; ++ *((unsigned long *)&__m128i_result0) = 0x000077529b522400; ++ __m128i_out = __lsx_vmulwod_d_wu (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x1111113111111141; ++ *((unsigned long *)&__m128i_op10) = 0x1111113111111121; ++ *((unsigned long *)&__m128i_result1) = 0x0000000111111312; ++ *((unsigned long *)&__m128i_result0) = 0x2222272111111410; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000001c88bf0; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000001c88bf0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0xfffffff800000003; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0xffffffff0015172b; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0xffffffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000800000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffffff800000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0001000100010001; ++ *((unsigned long *)&__m128i_op00) = 0x0001000600000001; ++ *((unsigned long *)&__m128i_op11) = 0x00000000c6c6c6c6; ++ *((unsigned long *)&__m128i_op10) = 0x00000000c6c6c6c6; ++ *((unsigned long *)&__m128i_result1) = 0x000000000000c6c7; ++ *((unsigned long *)&__m128i_result0) = 0x8d8d8d8d8d8cc6c6; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_op00) = 0x0a0000000a000000; ++ *((unsigned long *)&__m128i_op11) = 0x7f7f00007f7f7500; ++ *((unsigned long *)&__m128i_op10) = 0x3b42017f3a7f7f01; ++ *((unsigned long *)&__m128i_result1) = 0x04faf60009f5f092; ++ *((unsigned long *)&__m128i_result0) = 0x04fafa9200000000; ++ __m128i_out = __lsx_vmulwod_q_du (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-3.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-3.c +new file mode 100644 +index 000000000..9f5702e2c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vmulwod-3.c +@@ -0,0 +1,308 @@ ++/* { dg-do run } */ ++/* { dg-options "-mlsx -w -fno-strict-aliasing" } */ ++#include "../simd_correctness_check.h" ++#include <lsxintrin.h> ++ ++int ++main () ++{ ++ __m128i __m128i_op0, __m128i_op1, __m128i_op2, __m128i_out, __m128i_result; ++ __m128 __m128_op0, __m128_op1, __m128_op2, __m128_out, __m128_result; ++ __m128d __m128d_op0, __m128d_op1, __m128d_op2, __m128d_out, __m128d_result; ++ ++ int int_op0, int_op1, int_op2, int_out, int_result, i = 1, fail; ++ long int long_op0, long_op1, long_op2, lont_out, lont_result; ++ long int long_int_out, long_int_result; ++ unsigned int unsigned_int_out, unsigned_int_result; ++ unsigned long int unsigned_long_int_out, unsigned_long_int_result; ++ ++ *((unsigned long *)&__m128i_op01) = 0xbf8000000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0xcf00000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000002; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000000000ffff; ++ *((unsigned long *)&__m128i_op00) = 0x0000ff020000fff4; ++ *((unsigned long *)&__m128i_op11) = 0x7fc000007fc00000; ++ *((unsigned long *)&__m128i_op10) = 0x1e801ffc7fc00000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00001ee100000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x000000007fff7fff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x3f5ec0a0feefa0b0; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x00000000ff02d060; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_h_bu_b (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000001; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x80000000fff8fff8; ++ *((unsigned long *)&__m128i_op00) = 0x80000000fff80000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op00) = 0x0000001000000010; ++ *((unsigned long *)&__m128i_op11) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_op10) = 0x0010001000100010; ++ *((unsigned long *)&__m128i_result1) = 0x0000000001000100; ++ *((unsigned long *)&__m128i_result0) = 0x0000000001000100; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00000000004a294b; ++ *((unsigned long *)&__m128i_op00) = 0x00000000006d04bc; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x55aa55aa55aa55ab; ++ *((unsigned long *)&__m128i_op00) = 0xaa55555655aaaaa8; ++ *((unsigned long *)&__m128i_op11) = 0x7ef4002d21fc7001; ++ *((unsigned long *)&__m128i_op10) = 0x28bf02d1ec6a35b2; ++ *((unsigned long *)&__m128i_result1) = 0x2a7b7c9260f90ee2; ++ *((unsigned long *)&__m128i_result0) = 0x1b1c6cdfd57f5736; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op00) = 0x003fffff00000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000004040504; ++ *((unsigned long *)&__m128i_op00) = 0x0000000004040504; ++ *((unsigned long *)&__m128i_op11) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_op10) = 0x0000010100000101; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op00) = 0x7fff00007fff0000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_d_wu_w (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x000000ff000000ff; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000ffff00000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000ffff0000ffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000feff01; ++ *((unsigned long *)&__m128i_result0) = 0x00feff0100000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0101010202050120; ++ *((unsigned long *)&__m128i_op00) = 0x0101010102020202; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000000ff; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xf51cf8dad6040188; ++ *((unsigned long *)&__m128i_op00) = 0x0982e2daf234ed87; ++ *((unsigned long *)&__m128i_op11) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op10) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result1) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_result0) = 0x0ae3072529fbfe78; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x00000000000007f8; ++ *((unsigned long *)&__m128i_op10) = 0x00000000000007f8; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x00ff000000ff0000; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000005; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op00) = 0xffffffffffffffff; ++ *((unsigned long *)&__m128i_op11) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op10) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result1) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_result0) = 0x0000000000000000; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ *((unsigned long *)&__m128i_op01) = 0x030804010d090107; ++ *((unsigned long *)&__m128i_op00) = 0x0000000000000000; ++ *((unsigned long *)&__m128i_op11) = 0x1313131313131313; ++ *((unsigned long *)&__m128i_op10) = 0x1313131313131313; ++ *((unsigned long *)&__m128i_result1) = 0x0039d21e3229d4e8; ++ *((unsigned long *)&__m128i_result0) = 0x6d339b4f3b439885; ++ __m128i_out = __lsx_vmulwod_q_du_d (__m128i_op0, __m128i_op1); ++ ASSERTEQ_64 (__LINE__, __m128i_result, __m128i_out); ++ ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-tests-of-mstrict-align-option.patch
Added
@@ -0,0 +1,37 @@ +From f07b91862055533d779fbf76c12cb7c0ae75b53d Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 09:35:24 +0800 +Subject: PATCH 076/124 LoongArch: Add tests of -mstrict-align option. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/strict-align.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/testsuite/gcc.target/loongarch/strict-align.c | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/strict-align.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/strict-align.c b/gcc/testsuite/gcc.target/loongarch/strict-align.c +new file mode 100644 +index 000000000..040d84958 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/strict-align.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-Ofast -mstrict-align -mlasx" } */ ++/* { dg-final { scan-assembler-not "vfadd.s" } } */ ++ ++void ++foo (float *restrict x, float *restrict y) ++{ ++ x0 = x0 + y0; ++ x1 = x1 + y1; ++ x2 = x2 + y2; ++ x3 = x3 + y3; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Add-testsuite-framework-for-Loongson-SX-AS.patch
Added
@@ -0,0 +1,131 @@ +From aebd03c944312be767f03d129eeebc0c4cdf5b4a Mon Sep 17 00:00:00 2001 +From: Xiaolong Chen <chenxiaolong@loongson.cn> +Date: Mon, 11 Sep 2023 09:36:35 +0800 +Subject: PATCH 077/124 LoongArch: Add testsuite framework for Loongson + SX/ASX. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/vector/loongarch-vector.exp: New test. + * gcc.target/loongarch/vector/simd_correctness_check.h: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../loongarch/vector/loongarch-vector.exp | 42 +++++++++++++++ + .../loongarch/vector/simd_correctness_check.h | 54 +++++++++++++++++++ + 2 files changed, 96 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/loongarch-vector.exp + create mode 100644 gcc/testsuite/gcc.target/loongarch/vector/simd_correctness_check.h + +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/loongarch-vector.exp b/gcc/testsuite/gcc.target/loongarch/vector/loongarch-vector.exp +new file mode 100644 +index 000000000..2c37aa91d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/loongarch-vector.exp +@@ -0,0 +1,42 @@ ++#Copyright(C) 2023 Free Software Foundation, Inc. ++ ++#This program is free software; you can redistribute it and / or modify ++#it under the terms of the GNU General Public License as published by ++#the Free Software Foundation; either version 3 of the License, or ++#(at your option) any later version. ++# ++#This program is distributed in the hope that it will be useful, ++#but WITHOUT ANY WARRANTY; without even the implied warranty of ++#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the ++#GNU General Public License for more details. ++# ++#You should have received a copy of the GNU General Public License ++#along with GCC; see the file COPYING3.If not see ++# <http: //www.gnu.org/licenses/>. ++ ++#GCC testsuite that uses the `dg.exp' driver. ++ ++#Exit immediately if this isn't a LoongArch target. ++if !istarget loongarch*-*-* then { ++ return ++} ++ ++#Load support procs. ++load_lib gcc-dg.exp ++ ++#If a testcase doesn't have special options, use these. ++global DEFAULT_CFLAGS ++if !info exists DEFAULT_CFLAGS then { ++ set DEFAULT_CFLAGS " " ++} ++ ++#Initialize `dg'. ++dg-init ++ ++#Main loop. ++dg-runtest lsort glob -nocomplain $srcdir/$subdir/lsx/*.\cS\ \ ++ " -mlsx" $DEFAULT_CFLAGS ++dg-runtest lsort glob -nocomplain $srcdir/$subdir/lasx/*.\cS\ \ ++ " -mlasx" $DEFAULT_CFLAGS ++# All done. ++dg-finish +diff --git a/gcc/testsuite/gcc.target/loongarch/vector/simd_correctness_check.h b/gcc/testsuite/gcc.target/loongarch/vector/simd_correctness_check.h +new file mode 100644 +index 000000000..eb7fbd59c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/vector/simd_correctness_check.h +@@ -0,0 +1,54 @@ ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++ ++#define ASSERTEQ_64(line, ref, res) \ ++ do \ ++ { \ ++ int fail = 0; \ ++ for (size_t i = 0; i < sizeof (res) / sizeof (res0); ++i) \ ++ { \ ++ long *temp_ref = &refi, *temp_res = &resi; \ ++ if (abs (*temp_ref - *temp_res) > 0) \ ++ { \ ++ printf (" error: %s at line %ld , expected " #ref \ ++ "%ld:0x%lx, got: 0x%lx\n", \ ++ __FILE__, line, i, *temp_ref, *temp_res); \ ++ fail = 1; \ ++ } \ ++ } \ ++ if (fail == 1) \ ++ abort (); \ ++ } \ ++ while (0) ++ ++#define ASSERTEQ_32(line, ref, res) \ ++ do \ ++ { \ ++ int fail = 0; \ ++ for (size_t i = 0; i < sizeof (res) / sizeof (res0); ++i) \ ++ { \ ++ int *temp_ref = &refi, *temp_res = &resi; \ ++ if (abs (*temp_ref - *temp_res) > 0) \ ++ { \ ++ printf (" error: %s at line %ld , expected " #ref \ ++ "%ld:0x%x, got: 0x%x\n", \ ++ __FILE__, line, i, *temp_ref, *temp_res); \ ++ fail = 1; \ ++ } \ ++ } \ ++ if (fail == 1) \ ++ abort (); \ ++ } \ ++ while (0) ++ ++#define ASSERTEQ_int(line, ref, res) \ ++ do \ ++ { \ ++ if (ref != res) \ ++ { \ ++ printf (" error: %s at line %ld , expected %d, got %d\n", __FILE__, \ ++ line, ref, res); \ ++ } \ ++ } \ ++ while (0) +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Adjust-C-multilib-header-layout.patch
Added
@@ -0,0 +1,53 @@ +From a4bf17e87a965ed7f2bb1d2921fb9dd820c79a96 Mon Sep 17 00:00:00 2001 +From: Yang Yujie <yangyujie@loongson.cn> +Date: Thu, 7 Sep 2023 14:50:10 +0800 +Subject: PATCH 069/124 LoongArch: Adjust C++ multilib header layout. + +For LoongArch, the toplevel library build is always aliased to +one of the multilib variants. This patch installs it with the +actual MULTISUBDIR (instead of ".") so that the headers can be +reached by the compiler. + +This patch is an update of +https://gcc.gnu.org/pipermail/gcc-patches/2023-September/629435.html + +libstdc++-v3/ChangeLog: + + * configure.host: Register t-loongarch in tmake_file. + * config/cpu/loongarch/t-loongarch: New file. Manually refresh + MULTISUBDIR with $(shell $(CXX) --print-multi-directory). + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + libstdc++-v3/config/cpu/loongarch/t-loongarch | 1 + + libstdc++-v3/configure.host | 5 ++++- + 2 files changed, 5 insertions(+), 1 deletion(-) + create mode 100644 libstdc++-v3/config/cpu/loongarch/t-loongarch + +diff --git a/libstdc++-v3/config/cpu/loongarch/t-loongarch b/libstdc++-v3/config/cpu/loongarch/t-loongarch +new file mode 100644 +index 000000000..adfc8ebb9 +--- /dev/null ++++ b/libstdc++-v3/config/cpu/loongarch/t-loongarch +@@ -0,0 +1 @@ ++AM_MAKEFLAGS += " MULTISUBDIR=/$(shell $(CXX) --print-multi-directory)" +diff --git a/libstdc++-v3/configure.host b/libstdc++-v3/configure.host +index ec32980aa..592160e6d 100644 +--- a/libstdc++-v3/configure.host ++++ b/libstdc++-v3/configure.host +@@ -315,7 +315,10 @@ esac + # Set any OS-dependent and CPU-dependent bits. + # THIS TABLE IS SORTED. KEEP IT THAT WAY. + case "${host}" in +- *-*-linux* | *-*-uclinux*) ++ loongarch*) ++ tmake_file="cpu/loongarch/t-loongarch" ++ ;; ++ *-*-linux* | *-*-uclinux*) + case "${host_cpu}" in + i56786) + abi_baseline_pair=i486-linux-gnu +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Avoid-RTL-flag-check-failure-in-loongarch_.patch
Added
@@ -0,0 +1,55 @@ +From e82403e918e18fa8e8ecd0c9e26f2657cc814e12 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 24 Aug 2022 21:31:34 +0800 +Subject: PATCH 013/124 LoongArch: Avoid RTL flag check failure in + loongarch_classify_symbol + +SYMBOL_REF_TLS_MODEL invokes SYMBOL_REF_FLAGS, and SYMBOL_REF_FLAGS +invokes RTL_FLAG_CHECK1 and aborts when RTL code is not SYMBOL_REF. + +r13-1833 removed "gcc_assert (SYMBOL_REF_P (x))" before invoking +"SYMBOL_REF_TLS_MODEL (x)", indicating that it's now possible that "x" +is not a SYMBOL_REF. So we need to check if "x" is SYMBOL_REF first. + +This fixes a test failure happening with r13-2173 with RTL flag +checking enabled: + + pr106096.C:26:1: internal compiler error: RTL flag check: + SYMBOL_REF_FLAGS used with unexpected rtx code 'const' in + loongarch_classify_symbol + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_classify_symbol): + Return early if the rtx is not SYMBOL_REF. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 5 ++--- + 1 file changed, 2 insertions(+), 3 deletions(-) + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 04c4ddaed..452aba9d4 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -1633,14 +1633,13 @@ loongarch_rtx_constant_in_small_data_p (machine_mode mode) + static enum loongarch_symbol_type + loongarch_classify_symbol (const_rtx x) + { +- if (LABEL_REF_P (x)) ++ if (!SYMBOL_REF_P (x)) + return SYMBOL_PCREL; + + if (SYMBOL_REF_TLS_MODEL (x)) + return SYMBOL_TLS; + +- if (SYMBOL_REF_P (x) +- && !loongarch_symbol_binds_local_p (x)) ++ if (!loongarch_symbol_binds_local_p (x)) + return SYMBOL_GOT_DISP; + + return SYMBOL_PCREL; +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Avoid-non-returning-indirect-jumps-through.patch
Added
@@ -0,0 +1,62 @@ +From 7e759740048ee6f24c1055c32868fa21cabb4f75 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Wed, 7 Jun 2023 10:21:58 +0800 +Subject: PATCH 048/124 LoongArch: Avoid non-returning indirect jumps through + $ra PR110136 + +Micro-architecture unconditionally treats a "jr $ra" as "return from subroutine", +hence doing "jr $ra" would interfere with both subroutine return prediction and +the more general indirect branch prediction. + +Therefore, a problem like PR110136 can cause a significant increase in branch error +prediction rate and affect performance. The same problem exists with "indirect_jump". + +gcc/ChangeLog: + + PR target/110136 + * config/loongarch/loongarch.md: Modify the register constraints for template + "jumptable" and "indirect_jump" from "r" to "e". + +Co-authored-by: Andrew Pinski <apinski@marvell.com> +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index b23248c33..c79951c1d 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -2895,6 +2895,10 @@ + } + (set_attr "type" "branch")) + ++;; Micro-architecture unconditionally treats a "jr $ra" as "return from subroutine", ++;; non-returning indirect jumps through $ra would interfere with both subroutine ++;; return prediction and the more general indirect branch prediction. ++ + (define_expand "indirect_jump" + (set (pc) (match_operand 0 "register_operand")) + "" +@@ -2905,7 +2909,7 @@ + }) + + (define_insn "@indirect_jump<mode>" +- (set (pc) (match_operand:P 0 "register_operand" "r")) ++ (set (pc) (match_operand:P 0 "register_operand" "e")) + "" + "jr\t%0" + (set_attr "type" "jump") +@@ -2928,7 +2932,7 @@ + + (define_insn "@tablejump<mode>" + (set (pc) +- (match_operand:P 0 "register_operand" "r")) ++ (match_operand:P 0 "register_operand" "e")) + (use (label_ref (match_operand 1 "" ""))) + "" + "jr\t%0" +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Change-the-default-value-of-LARCH_CALL_RAT.patch
Added
@@ -0,0 +1,41 @@ +From 59824f1062d77d0e02ea82d47415bf95c235de87 Mon Sep 17 00:00:00 2001 +From: chenxiaolong <chenxl04200420@163.com> +Date: Thu, 15 Jun 2023 02:46:24 +0000 +Subject: PATCH 046/124 LoongArch: Change the default value of + LARCH_CALL_RATIO to 6. + +During the regression testing of the LoongArch architecture GCC, it was found +that the tests in the pr90883.C file failed. The problem was modulated and +found that the error was caused by setting the macro LARCH_CALL_RATIO to a too +large value. Combined with the actual LoongArch architecture, the different +thresholds for meeting the test conditions were tested using the engineering method +(SPEC CPU 2006), and the results showed that its optimal threshold should be set +to 6. + +gcc/ChangeLog: + + * config/loongarch/loongarch.h (LARCH_CALL_RATIO): Modify the value + of macro LARCH_CALL_RATIO on LoongArch to make it perform optimally. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index 44ebadfaa..0e35d4dec 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -1073,7 +1073,7 @@ typedef struct { + /* The base cost of a memcpy call, for MOVE_RATIO and friends. These + values were determined experimentally by benchmarking with CSiBE. + */ +-#define LARCH_CALL_RATIO 8 ++#define LARCH_CALL_RATIO 6 + + /* Any loop-based implementation of cpymemsi will have at least + LARCH_MAX_MOVE_OPS_PER_LOOP_ITER memory-to-memory +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Change-the-value-of-branch_cost-from-2-to-.patch
Added
@@ -0,0 +1,69 @@ +From 7e843ed8da168a05eb04eee0b14cbe681bf798fe Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Wed, 13 Sep 2023 11:01:34 +0800 +Subject: PATCH 123/124 LoongArch: Change the value of branch_cost from 2 to + 6. + +gcc/ChangeLog: + + * config/loongarch/loongarch-def.c: Modify the default value of + branch_cost. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/cmov_ii.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-def.c | 4 ++-- + gcc/testsuite/gcc.target/loongarch/cmov_ii.c | 15 +++++++++++++++ + 2 files changed, 17 insertions(+), 2 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/cmov_ii.c + +diff --git a/gcc/config/loongarch/loongarch-def.c b/gcc/config/loongarch/loongarch-def.c +index d29d5f001..eeb32dbf6 100644 +--- a/gcc/config/loongarch/loongarch-def.c ++++ b/gcc/config/loongarch/loongarch-def.c +@@ -85,7 +85,7 @@ loongarch_cpu_alignN_TUNE_TYPES = { + .int_mult_di = COSTS_N_INSNS (1), \ + .int_div_si = COSTS_N_INSNS (4), \ + .int_div_di = COSTS_N_INSNS (6), \ +- .branch_cost = 2, \ ++ .branch_cost = 6, \ + .memory_latency = 4 + + /* The following properties cannot be looked up directly using "cpucfg". +@@ -118,7 +118,7 @@ loongarch_rtx_cost_optimize_size = { + .int_mult_di = 4, + .int_div_si = 4, + .int_div_di = 4, +- .branch_cost = 2, ++ .branch_cost = 6, + .memory_latency = 4, + }; + +diff --git a/gcc/testsuite/gcc.target/loongarch/cmov_ii.c b/gcc/testsuite/gcc.target/loongarch/cmov_ii.c +new file mode 100644 +index 000000000..21b468e8a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/cmov_ii.c +@@ -0,0 +1,15 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++/* { dg-final { scan-assembler "test:.*xor.*maskeqz.*masknez.*or.*" } } */ ++ ++extern void foo_ii (int *, int *, int *, int *); ++ ++int ++test (void) ++{ ++ int a, b; ++ int c, d, out; ++ foo_ii (&a, &b, &c, &d); ++ out = a == b ? c : d; ++ return out; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Change-the-value-of-macro-TRY_EMPTY_VM_SPA.patch
Added
@@ -0,0 +1,49 @@ +From 6e9265e571a63deb2584704a0b088a6d67ec8af5 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Mon, 20 Feb 2023 16:47:11 +0800 +Subject: PATCH 037/124 LoongArch: Change the value of macro + TRY_EMPTY_VM_SPACE from 0x8000000000 to 0x1000000000. + +The PCH mechanism first tries to map the .gch file to the virtual memory +space pointed to by TRY_EMPTY_VM_SPACE during the compilation process. + +The original value of TRY_EMPTY_VM_SPACE macro is 0x8000000000, +but like la464 only has 40 bits of virtual address space, this value +just exceeds the address range. + +If we want to support chips with less than 40 bits virtual addresses, +then the value of this macro needs to be set small. I think setting +this value small will increase the probability of virtual address +mapping failure. And the purpose of pch is to make compilation faster, +but I think we rarely compile on embedded systems. So this situation +may not be within our consideration. + +So change the value of this macro to 0x1000000000. + +gcc/ChangeLog: + + * config/host-linux.cc (TRY_EMPTY_VM_SPACE): Modify the value of + the macro to 0x1000000000. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/host-linux.cc | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/config/host-linux.cc b/gcc/config/host-linux.cc +index 817d3c087..d93cfc064 100644 +--- a/gcc/config/host-linux.cc ++++ b/gcc/config/host-linux.cc +@@ -99,7 +99,7 @@ + #elif defined(__riscv) && defined (__LP64__) + # define TRY_EMPTY_VM_SPACE 0x1000000000 + #elif defined(__loongarch__) && defined(__LP64__) +-# define TRY_EMPTY_VM_SPACE 0x8000000000 ++# define TRY_EMPTY_VM_SPACE 0x1000000000 + #else + # define TRY_EMPTY_VM_SPACE 0 + #endif +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Define-the-macro-ASM_PREFERRED_EH_DATA_FOR.patch
Added
@@ -0,0 +1,139 @@ +From 05c1df09c70cd0ed48f0644890f69a0128b17a98 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Fri, 29 Jul 2022 09:44:52 +0800 +Subject: PATCH 008/124 LoongArch: Define the macro + ASM_PREFERRED_EH_DATA_FORMAT by checking the assembler's support for eh_frame + encoding. + +.eh_frame DW_EH_PE_pcrel encoding format is not supported by gas <= 2.39. +Check if the assembler support DW_EH_PE_PCREL encoding and define .eh_frame +encoding type. + +gcc/ChangeLog: + + * config.in: Regenerate. + * config/loongarch/loongarch.h (ASM_PREFERRED_EH_DATA_FORMAT): + Select the value of the macro definition according to whether + HAVE_AS_EH_FRAME_PCREL_ENCODING_SUPPORT is defined. + * configure: Regenerate. + * configure.ac: Reinstate HAVE_AS_EH_FRAME_PCREL_ENCODING_SUPPORT test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config.in | 8 +++++++- + gcc/config/loongarch/loongarch.h | 5 +++++ + gcc/configure | 34 ++++++++++++++++++++++++++++++++ + gcc/configure.ac | 8 ++++++++ + 4 files changed, 54 insertions(+), 1 deletion(-) + +diff --git a/gcc/config.in b/gcc/config.in +index 64c27c9cf..67ce422f2 100644 +--- a/gcc/config.in ++++ b/gcc/config.in +@@ -404,13 +404,19 @@ + #endif + + ++/* Define if your assembler supports eh_frame pcrel encoding. */ ++#ifndef USED_FOR_TARGET ++#undef HAVE_AS_EH_FRAME_PCREL_ENCODING_SUPPORT ++#endif ++ ++ + /* Define if your assembler supports the R_PPC64_ENTRY relocation. */ + #ifndef USED_FOR_TARGET + #undef HAVE_AS_ENTRY_MARKERS + #endif + + +-/* Define if your assembler supports explicit relocations. */ ++/* Define if your assembler supports explicit relocation. */ + #ifndef USED_FOR_TARGET + #undef HAVE_AS_EXPLICIT_RELOCS + #endif +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index 12f209047..a52a81adf 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -1130,8 +1130,13 @@ struct GTY (()) machine_function + }; + #endif + ++#ifdef HAVE_AS_EH_FRAME_PCREL_ENCODING_SUPPORT ++#define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \ ++ (((GLOBAL) ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel | DW_EH_PE_sdata4) ++#else + #define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \ + (((GLOBAL) ? DW_EH_PE_indirect : 0) | DW_EH_PE_absptr) ++#endif + + /* Do emit .note.GNU-stack by default. */ + #ifndef NEED_INDICATE_EXEC_STACK +diff --git a/gcc/configure b/gcc/configure +index 840eddc7c..3788e240a 100755 +--- a/gcc/configure ++++ b/gcc/configure +@@ -28857,6 +28857,40 @@ if test $gcc_cv_as_loongarch_explicit_relocs = yes; then + + $as_echo "#define HAVE_AS_EXPLICIT_RELOCS 1" >>confdefs.h + ++fi ++ ++ { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for eh_frame pcrel encoding support" >&5 ++$as_echo_n "checking assembler for eh_frame pcrel encoding support... " >&6; } ++if ${gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support+:} false; then : ++ $as_echo_n "(cached) " >&6 ++else ++ gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support=no ++ if test x$gcc_cv_as != x; then ++ $as_echo '.cfi_startproc ++ .cfi_personality 0x9b,a ++ .cfi_lsda 0x1b,b ++ .cfi_endproc' > conftest.s ++ if { ac_try='$gcc_cv_as $gcc_cv_as_flags -o conftest.o conftest.s >&5' ++ { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 ++ test $ac_status = 0; }; } ++ then ++ gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support=yes ++ else ++ echo "configure: failed program was" >&5 ++ cat conftest.s >&5 ++ fi ++ rm -f conftest.o conftest.s ++ fi ++fi ++{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support" >&5 ++$as_echo "$gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support" >&6; } ++if test $gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support = yes; then ++ ++$as_echo "#define HAVE_AS_EH_FRAME_PCREL_ENCODING_SUPPORT 1" >>confdefs.h ++ + fi + + ;; +diff --git a/gcc/configure.ac b/gcc/configure.ac +index 975c852c6..1c376e0d4 100644 +--- a/gcc/configure.ac ++++ b/gcc/configure.ac +@@ -5324,6 +5324,14 @@ x: + a:pcalau12i $t0,%pc_hi20(a),, + AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1, + Define if your assembler supports explicit relocation.)) ++ gcc_GAS_CHECK_FEATURE(eh_frame pcrel encoding support, ++ gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support,, ++ .cfi_startproc ++ .cfi_personality 0x9b,a ++ .cfi_lsda 0x1b,b ++ .cfi_endproc,, ++ AC_DEFINE(HAVE_AS_EH_FRAME_PCREL_ENCODING_SUPPORT, 1, ++ Define if your assembler supports eh_frame pcrel encoding.)) + ;; + s390*-*-*) + gcc_GAS_CHECK_FEATURE(.gnu_attribute support, +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Don-t-add-crtfastmath.o-for-shared.patch
Added
@@ -0,0 +1,34 @@ +From 2e19311d1bf4f932f5e67f6866123b895b12c97f Mon Sep 17 00:00:00 2001 +From: Richard Biener <rguenther@suse.de> +Date: Fri, 13 Jan 2023 09:01:12 +0100 +Subject: PATCH 035/124 LoongArch: Don't add crtfastmath.o for -shared + +Don't add crtfastmath.o for -shared to avoid altering the FP +environment when loading a shared library. + + PR target/55522 + * config/loongarch/gnu-user.h (GNU_USER_TARGET_MATHFILE_SPEC): + Don't add crtfastmath.o for -shared. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/gnu-user.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/config/loongarch/gnu-user.h b/gcc/config/loongarch/gnu-user.h +index c5b1afe53..1dc6add62 100644 +--- a/gcc/config/loongarch/gnu-user.h ++++ b/gcc/config/loongarch/gnu-user.h +@@ -49,7 +49,7 @@ along with GCC; see the file COPYING3. If not see + /* Similar to standard Linux, but adding -ffast-math support. */ + #undef GNU_USER_TARGET_MATHFILE_SPEC + #define GNU_USER_TARGET_MATHFILE_SPEC \ +- "%{Ofast|ffast-math|funsafe-math-optimizations:crtfastmath.o%s}" ++ "%{Ofast|ffast-math|funsafe-math-optimizations:%{!shared:crtfastmath.o%s}}" + + #undef LIB_SPEC + #define LIB_SPEC GNU_USER_TARGET_LIB_SPEC +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Enable-free-starting-at-O2.patch
Added
@@ -0,0 +1,71 @@ +From 0369836718ffb25ac64c135e748f409302068a56 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Mon, 28 Aug 2023 11:30:21 +0800 +Subject: PATCH 052/124 LoongArch: Enable '-free' starting at -O2. + +gcc/ChangeLog: + + * common/config/loongarch/loongarch-common.cc: + Enable '-free' on O2 and above. + * doc/invoke.texi: Modify the description information + of the '-free' compilation option and add the LoongArch + description. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/sign-extend.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../config/loongarch/loongarch-common.cc | 1 + + .../gcc.target/loongarch/sign-extend.c | 25 +++++++++++++++++++ + 2 files changed, 26 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/sign-extend.c + +diff --git a/gcc/common/config/loongarch/loongarch-common.cc b/gcc/common/config/loongarch/loongarch-common.cc +index f8b4660fa..309fcb280 100644 +--- a/gcc/common/config/loongarch/loongarch-common.cc ++++ b/gcc/common/config/loongarch/loongarch-common.cc +@@ -35,6 +35,7 @@ static const struct default_options loongarch_option_optimization_table = + { + { OPT_LEVELS_ALL, OPT_fasynchronous_unwind_tables, NULL, 1 }, + { OPT_LEVELS_1_PLUS, OPT_fsection_anchors, NULL, 1 }, ++ { OPT_LEVELS_2_PLUS, OPT_free, NULL, 1 }, + { OPT_LEVELS_NONE, 0, NULL, 0 } + }; + +diff --git a/gcc/testsuite/gcc.target/loongarch/sign-extend.c b/gcc/testsuite/gcc.target/loongarch/sign-extend.c +new file mode 100644 +index 000000000..3f339d06b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/sign-extend.c +@@ -0,0 +1,25 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O2" } */ ++/* { dg-final { scan-assembler-times "slli.w" 1 } } */ ++ ++extern int PL_savestack_ix; ++extern int PL_regsize; ++extern int PL_savestack_max; ++void Perl_savestack_grow_cnt (int need); ++extern void Perl_croak (char *); ++ ++int ++S_regcppush(int parenfloor) ++{ ++ int retval = PL_savestack_ix; ++ int paren_elems_to_push = (PL_regsize - parenfloor) * 4; ++ int p; ++ ++ if (paren_elems_to_push < 0) ++ Perl_croak ("panic: paren_elems_to_push < 0"); ++ ++ if (PL_savestack_ix + (paren_elems_to_push + 6) > PL_savestack_max) ++ Perl_savestack_grow_cnt (paren_elems_to_push + 6); ++ ++ return retval; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Enable-fsched-pressure-by-default-at-O1-an.patch
Added
@@ -0,0 +1,33 @@ +From a9f72e237d5c176e4ef8ba03a8b4ee5c5daa25fb Mon Sep 17 00:00:00 2001 +From: Guo Jie <guojie@loongson.cn> +Date: Fri, 8 Sep 2023 10:00:21 +0800 +Subject: PATCH 071/124 LoongArch: Enable -fsched-pressure by default at -O1 + and higher. + +gcc/ChangeLog: + + * common/config/loongarch/loongarch-common.cc: + (default_options loongarch_option_optimization_table): + Default to -fsched-pressure. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/common/config/loongarch/loongarch-common.cc | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/gcc/common/config/loongarch/loongarch-common.cc b/gcc/common/config/loongarch/loongarch-common.cc +index 309fcb280..c8bc5718d 100644 +--- a/gcc/common/config/loongarch/loongarch-common.cc ++++ b/gcc/common/config/loongarch/loongarch-common.cc +@@ -36,6 +36,7 @@ static const struct default_options loongarch_option_optimization_table = + { OPT_LEVELS_ALL, OPT_fasynchronous_unwind_tables, NULL, 1 }, + { OPT_LEVELS_1_PLUS, OPT_fsection_anchors, NULL, 1 }, + { OPT_LEVELS_2_PLUS, OPT_free, NULL, 1 }, ++ { OPT_LEVELS_1_PLUS, OPT_fsched_pressure, NULL, 1 }, + { OPT_LEVELS_NONE, 0, NULL, 0 } + }; + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Enable-shrink-wrapping.patch
Added
@@ -0,0 +1,309 @@ +From e86c9ece7ae922fe80017ba2ffe22f6267531682 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Sun, 23 Apr 2023 20:52:22 +0800 +Subject: PATCH 045/124 LoongArch: Enable shrink wrapping + +This commit implements the target macros for shrink wrapping of function +prologues/epilogues shrink wrapping on LoongArch. + +Bootstrapped and regtested on loongarch64-linux-gnu. I don't have an +access to SPEC CPU so I hope the reviewer can perform a benchmark to see +if there is real benefit. + +gcc/ChangeLog: + + * config/loongarch/loongarch.h (struct machine_function): Add + reg_is_wrapped_separately array for register wrapping + information. + * config/loongarch/loongarch.cc + (loongarch_get_separate_components): New function. + (loongarch_components_for_bb): Likewise. + (loongarch_disqualify_components): Likewise. + (loongarch_process_components): Likewise. + (loongarch_emit_prologue_components): Likewise. + (loongarch_emit_epilogue_components): Likewise. + (loongarch_set_handled_components): Likewise. + (TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS): Define. + (TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB): Likewise. + (TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS): Likewise. + (TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS): Likewise. + (TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS): Likewise. + (TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS): Likewise. + (loongarch_for_each_saved_reg): Skip registers that are wrapped + separately. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/shrink-wrap.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 179 +++++++++++++++++- + gcc/config/loongarch/loongarch.h | 2 + + .../gcc.target/loongarch/shrink-wrap.c | 19 ++ + 3 files changed, 197 insertions(+), 3 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/shrink-wrap.c + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index d3c6f22ad..4c0f393b6 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -64,6 +64,7 @@ along with GCC; see the file COPYING3. If not see + #include "builtins.h" + #include "rtl-iter.h" + #include "opts.h" ++#include "function-abi.h" + + /* This file should be included last. */ + #include "target-def.h" +@@ -1014,19 +1015,23 @@ loongarch_for_each_saved_reg (HOST_WIDE_INT sp_offset, + for (int regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++) + if (BITSET_P (cfun->machine->frame.mask, regno - GP_REG_FIRST)) + { +- loongarch_save_restore_reg (word_mode, regno, offset, fn); ++ if (!cfun->machine->reg_is_wrapped_separatelyregno) ++ loongarch_save_restore_reg (word_mode, regno, offset, fn); ++ + offset -= UNITS_PER_WORD; + } + + /* This loop must iterate over the same space as its companion in + loongarch_compute_frame_info. */ + offset = cfun->machine->frame.fp_sp_offset - sp_offset; ++ machine_mode mode = TARGET_DOUBLE_FLOAT ? DFmode : SFmode; ++ + for (int regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno++) + if (BITSET_P (cfun->machine->frame.fmask, regno - FP_REG_FIRST)) + { +- machine_mode mode = TARGET_DOUBLE_FLOAT ? DFmode : SFmode; ++ if (!cfun->machine->reg_is_wrapped_separatelyregno) ++ loongarch_save_restore_reg (word_mode, regno, offset, fn); + +- loongarch_save_restore_reg (mode, regno, offset, fn); + offset -= GET_MODE_SIZE (mode); + } + } +@@ -6630,6 +6635,151 @@ loongarch_asan_shadow_offset (void) + return TARGET_64BIT ? (HOST_WIDE_INT_1 << 46) : 0; + } + ++static sbitmap ++loongarch_get_separate_components (void) ++{ ++ HOST_WIDE_INT offset; ++ sbitmap components = sbitmap_alloc (FIRST_PSEUDO_REGISTER); ++ bitmap_clear (components); ++ offset = cfun->machine->frame.gp_sp_offset; ++ ++ /* The stack should be aligned to 16-bytes boundary, so we can make the use ++ of ldptr instructions. */ ++ gcc_assert (offset % UNITS_PER_WORD == 0); ++ ++ for (unsigned int regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++) ++ if (BITSET_P (cfun->machine->frame.mask, regno - GP_REG_FIRST)) ++ { ++ /* We can wrap general registers saved at sp, sp + 32768) using the ++ ldptr/stptr instructions. For large offsets a pseudo register ++ might be needed which cannot be created during the shrink ++ wrapping pass. ++ ++ TODO: This may need a revise when we add LA32 as ldptr.w is not ++ guaranteed available by the manual. */ ++ if (offset < 32768) ++ bitmap_set_bit (components, regno); ++ ++ offset -= UNITS_PER_WORD; ++ } ++ ++ offset = cfun->machine->frame.fp_sp_offset; ++ for (unsigned int regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno++) ++ if (BITSET_P (cfun->machine->frame.fmask, regno - FP_REG_FIRST)) ++ { ++ /* We can only wrap FP registers with imm12 offsets. For large ++ offsets a pseudo register might be needed which cannot be ++ created during the shrink wrapping pass. */ ++ if (IMM12_OPERAND (offset)) ++ bitmap_set_bit (components, regno); ++ ++ offset -= UNITS_PER_FPREG; ++ } ++ ++ /* Don't mess with the hard frame pointer. */ ++ if (frame_pointer_needed) ++ bitmap_clear_bit (components, HARD_FRAME_POINTER_REGNUM); ++ ++ bitmap_clear_bit (components, RETURN_ADDR_REGNUM); ++ ++ return components; ++} ++ ++static sbitmap ++loongarch_components_for_bb (basic_block bb) ++{ ++ /* Registers are used in a bb if they are in the IN, GEN, or KILL sets. */ ++ auto_bitmap used; ++ bitmap_copy (used, DF_LIVE_IN (bb)); ++ bitmap_ior_into (used, &DF_LIVE_BB_INFO (bb)->gen); ++ bitmap_ior_into (used, &DF_LIVE_BB_INFO (bb)->kill); ++ ++ sbitmap components = sbitmap_alloc (FIRST_PSEUDO_REGISTER); ++ bitmap_clear (components); ++ ++ function_abi_aggregator callee_abis; ++ rtx_insn *insn; ++ FOR_BB_INSNS (bb, insn) ++ if (CALL_P (insn)) ++ callee_abis.note_callee_abi (insn_callee_abi (insn)); ++ ++ HARD_REG_SET extra_caller_saves = ++ callee_abis.caller_save_regs (*crtl->abi); ++ ++ for (unsigned int regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++) ++ if (!fixed_regsregno ++ && !crtl->abi->clobbers_full_reg_p (regno) ++ && (TEST_HARD_REG_BIT (extra_caller_saves, regno) || ++ bitmap_bit_p (used, regno))) ++ bitmap_set_bit (components, regno); ++ ++ for (unsigned int regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno++) ++ if (!fixed_regsregno ++ && !crtl->abi->clobbers_full_reg_p (regno) ++ && (TEST_HARD_REG_BIT (extra_caller_saves, regno) || ++ bitmap_bit_p (used, regno))) ++ bitmap_set_bit (components, regno); ++ ++ return components; ++} ++ ++static void ++loongarch_disqualify_components (sbitmap, edge, sbitmap, bool) ++{ ++ /* Do nothing. */ ++} ++ ++static void ++loongarch_process_components (sbitmap components, loongarch_save_restore_fn fn) ++{ ++ HOST_WIDE_INT offset = cfun->machine->frame.gp_sp_offset; ++ ++ for (unsigned int regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++) ++ if (BITSET_P (cfun->machine->frame.mask, regno - GP_REG_FIRST)) ++ { ++ if (bitmap_bit_p (components, regno)) ++ loongarch_save_restore_reg (word_mode, regno, offset, fn); ++ ++ offset -= UNITS_PER_WORD; ++ } ++ ++ offset = cfun->machine->frame.fp_sp_offset; ++ machine_mode mode = TARGET_DOUBLE_FLOAT ? DFmode : SFmode; ++ ++ for (unsigned int regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno++) ++ if (BITSET_P (cfun->machine->frame.fmask, regno - FP_REG_FIRST)) ++ { ++ if (bitmap_bit_p (components, regno)) ++ loongarch_save_restore_reg (mode, regno, offset, fn); ++ ++ offset -= UNITS_PER_FPREG; ++ } ++} ++ ++static void ++loongarch_emit_prologue_components (sbitmap components) ++{ ++ loongarch_process_components (components, loongarch_save_reg); ++} ++ ++static void ++loongarch_emit_epilogue_components (sbitmap components) ++{ ++ loongarch_process_components (components, loongarch_restore_reg); ++} ++ ++static void ++loongarch_set_handled_components (sbitmap components) ++{ ++ for (unsigned int regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++) ++ if (bitmap_bit_p (components, regno)) ++ cfun->machine->reg_is_wrapped_separatelyregno = true; ++ ++ for (unsigned int regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno++) ++ if (bitmap_bit_p (components, regno)) ++ cfun->machine->reg_is_wrapped_separatelyregno = true; ++} ++ + /* Initialize the GCC target structure. */ + #undef TARGET_ASM_ALIGNED_HI_OP + #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t" +@@ -6827,6 +6977,29 @@ loongarch_asan_shadow_offset (void) + #undef TARGET_ASAN_SHADOW_OFFSET + #define TARGET_ASAN_SHADOW_OFFSET loongarch_asan_shadow_offset + ++#undef TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS ++#define TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS \ ++ loongarch_get_separate_components ++ ++#undef TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB ++#define TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB loongarch_components_for_bb ++ ++#undef TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS ++#define TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS \ ++ loongarch_disqualify_components ++ ++#undef TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS ++#define TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS \ ++ loongarch_emit_prologue_components ++ ++#undef TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS ++#define TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS \ ++ loongarch_emit_epilogue_components ++ ++#undef TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS ++#define TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS \ ++ loongarch_set_handled_components ++ + struct gcc_target targetm = TARGET_INITIALIZER; + + #include "gt-loongarch.h" +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index af24bfa01..44ebadfaa 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -1147,6 +1147,8 @@ struct GTY (()) machine_function + /* The current frame information, calculated by loongarch_compute_frame_info. + */ + struct loongarch_frame_info frame; ++ ++ bool reg_is_wrapped_separatelyFIRST_PSEUDO_REGISTER; + }; + #endif + +diff --git a/gcc/testsuite/gcc.target/loongarch/shrink-wrap.c b/gcc/testsuite/gcc.target/loongarch/shrink-wrap.c +new file mode 100644 +index 000000000..1431536c5 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/shrink-wrap.c +@@ -0,0 +1,19 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O -fshrink-wrap" } */ ++ ++/* We should not save anything before checking the value of x. */ ++/* { dg-final { scan-assembler-not "st(ptr)?\\\.\dw\.*b(eq|ne)z" } } */ ++ ++int ++foo (int x) ++{ ++ __asm__ ("nop" :); ++ if (x) ++ { ++ __asm__ ("" ::: "s0", "s1"); ++ return x; ++ } ++ ++ __asm__ ("" ::: "s2", "s3"); ++ return 0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fix-MUSL_DYNAMIC_LINKER.patch
Added
@@ -0,0 +1,43 @@ +From 3db61acfbaa773568fad2bc31d950c6d9b3729b0 Mon Sep 17 00:00:00 2001 +From: Peng Fan <fanpeng@loongson.cn> +Date: Wed, 19 Apr 2023 16:23:42 +0800 +Subject: PATCH 044/124 LoongArch: Fix MUSL_DYNAMIC_LINKER + +The system based on musl has no '/lib64', so change it. + +https://wiki.musl-libc.org/guidelines-for-distributions.html, +"Multilib/multi-arch" section of this introduces it. + +gcc/ + * config/loongarch/gnu-user.h (MUSL_DYNAMIC_LINKER): Redefine. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Suggested-by: Xi Ruoyao <xry111@xry111.site> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/gnu-user.h | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +diff --git a/gcc/config/loongarch/gnu-user.h b/gcc/config/loongarch/gnu-user.h +index 1dc6add62..44e4f2575 100644 +--- a/gcc/config/loongarch/gnu-user.h ++++ b/gcc/config/loongarch/gnu-user.h +@@ -33,9 +33,14 @@ along with GCC; see the file COPYING3. If not see + #define GLIBC_DYNAMIC_LINKER \ + "/lib" ABI_GRLEN_SPEC "/ld-linux-loongarch-" ABI_SPEC ".so.1" + ++#define MUSL_ABI_SPEC \ ++ "%{mabi=lp64d:-lp64d}" \ ++ "%{mabi=lp64f:-lp64f}" \ ++ "%{mabi=lp64s:-lp64s}" ++ + #undef MUSL_DYNAMIC_LINKER + #define MUSL_DYNAMIC_LINKER \ +- "/lib" ABI_GRLEN_SPEC "/ld-musl-loongarch-" ABI_SPEC ".so.1" ++ "/lib/ld-musl-loongarch" ABI_GRLEN_SPEC MUSL_ABI_SPEC ".so.1" + + #undef GNU_USER_TARGET_LINK_SPEC + #define GNU_USER_TARGET_LINK_SPEC \ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fix-bug-in-loongarch_emit_stack_tie-PR1104.patch
Added
@@ -0,0 +1,43 @@ +From 7c8fc6b414dc1718e71e0d05c7a78498e06eb499 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 29 Jun 2023 19:30:59 +0800 +Subject: PATCH 053/124 LoongArch: Fix bug in loongarch_emit_stack_tie + PR110484. + +Which may result in implicit references to $fp when frame_pointer_needed is false, +causing regs_ever_live$fp to be true when $fp is not explicitly used, +resulting in $fp being used as the target replacement register in the rnreg pass. + +The bug originates from SPEC2017 541.leela_r(-flto). + +gcc/ChangeLog: + + PR target/110484 + * config/loongarch/loongarch.cc (loongarch_emit_stack_tie): Use the + frame_pointer_needed to determine whether to use the $fp register. + +Co-authored-by: Guo Jie <guojie@loongson.cn> +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index caacfa8a3..7b48e3216 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -1109,7 +1109,9 @@ loongarch_first_stack_step (struct loongarch_frame_info *frame) + static void + loongarch_emit_stack_tie (void) + { +- emit_insn (gen_stack_tie (Pmode, stack_pointer_rtx, hard_frame_pointer_rtx)); ++ emit_insn (gen_stack_tie (Pmode, stack_pointer_rtx, ++ frame_pointer_needed ? hard_frame_pointer_rtx ++ : stack_pointer_rtx)); + } + + #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP) +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fix-bug-of-optab-di3_fake.patch
Added
@@ -0,0 +1,123 @@ +From df1df2e7b7e27bd9fba77f572d74d833aff4a202 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Mon, 11 Sep 2023 16:20:29 +0800 +Subject: PATCH 122/124 LoongArch: Fix bug of '<optab>di3_fake'. + + PR target/111334 + +gcc/ChangeLog: + + * config/loongarch/loongarch.md: Fix bug of '<optab>di3_fake'. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/pr111334.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 20 ++++++---- + gcc/testsuite/gcc.target/loongarch/pr111334.c | 39 +++++++++++++++++++ + 2 files changed, 52 insertions(+), 7 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/pr111334.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 264cd325c..7746116e6 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -72,6 +72,9 @@ + UNSPEC_LUI_H_HI12 + UNSPEC_TLS_LOW + ++ ;; Fake div.wu mod.wu ++ UNSPEC_FAKE_ANY_DIV ++ + UNSPEC_SIBCALL_VALUE_MULTIPLE_INTERNAL_1 + UNSPEC_CALL_VALUE_MULTIPLE_INTERNAL_1 + ) +@@ -900,7 +903,7 @@ + (match_operand:GPR 2 "register_operand"))) + "" + { +- if (GET_MODE (operands0) == SImode) ++ if (GET_MODE (operands0) == SImode && TARGET_64BIT) + { + rtx reg1 = gen_reg_rtx (DImode); + rtx reg2 = gen_reg_rtx (DImode); +@@ -920,9 +923,9 @@ + }) + + (define_insn "*<optab><mode>3" +- (set (match_operand:GPR 0 "register_operand" "=r,&r,&r") +- (any_div:GPR (match_operand:GPR 1 "register_operand" "r,r,0") +- (match_operand:GPR 2 "register_operand" "r,r,r"))) ++ (set (match_operand:X 0 "register_operand" "=r,&r,&r") ++ (any_div:X (match_operand:X 1 "register_operand" "r,r,0") ++ (match_operand:X 2 "register_operand" "r,r,r"))) + "" + { + return loongarch_output_division ("<insn>.<d><u>\t%0,%1,%2", operands); +@@ -938,9 +941,12 @@ + (define_insn "<optab>di3_fake" + (set (match_operand:DI 0 "register_operand" "=r,&r,&r") + (sign_extend:DI +- (any_div:SI (match_operand:DI 1 "register_operand" "r,r,0") +- (match_operand:DI 2 "register_operand" "r,r,r")))) +- "" ++ (unspec:SI ++ (subreg:SI ++ (any_div:DI (match_operand:DI 1 "register_operand" "r,r,0") ++ (match_operand:DI 2 "register_operand" "r,r,r")) 0) ++ UNSPEC_FAKE_ANY_DIV))) ++ "TARGET_64BIT" + { + return loongarch_output_division ("<insn>.w<u>\t%0,%1,%2", operands); + } +diff --git a/gcc/testsuite/gcc.target/loongarch/pr111334.c b/gcc/testsuite/gcc.target/loongarch/pr111334.c +new file mode 100644 +index 000000000..47366afcb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/pr111334.c +@@ -0,0 +1,39 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++ ++unsigned ++util_next_power_of_two (unsigned x) ++{ ++ return (1 << __builtin_clz (x - 1)); ++} ++ ++extern int create_vec_from_array (void); ++ ++struct ac_shader_args { ++ struct { ++ unsigned char offset; ++ unsigned char size; ++ } args384; ++}; ++ ++struct isel_context { ++ const struct ac_shader_args* args; ++ int arg_temps384; ++}; ++ ++ ++void ++add_startpgm (struct isel_context* ctx, unsigned short arg_count) ++{ ++ ++ for (unsigned i = 0, arg = 0; i < arg_count; i++) ++ { ++ unsigned size = ctx->args->argsi.size; ++ unsigned reg = ctx->args->argsi.offset; ++ ++ if (reg % ( 4 < util_next_power_of_two (size) ++ ? 4 : util_next_power_of_two (size))) ++ ctx->arg_tempsi = create_vec_from_array (); ++ } ++} ++ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fix-pr106828-by-define-hook-TARGET_ASAN_SH.patch
Added
@@ -0,0 +1,69 @@ +From a70fe51d9813d490a89cbc8da1ae4b040bf8b37e Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Wed, 7 Sep 2022 11:25:45 +0800 +Subject: PATCH 017/124 LoongArch: Fix pr106828 by define hook + TARGET_ASAN_SHADOW_OFFSET in loongarch backend PR106828. + +gcc/ChangeLog: + + PR target/106828 + * config/loongarch/loongarch.cc (loongarch_asan_shadow_offset): New. + (TARGET_ASAN_SHADOW_OFFSET): New. + +gcc/testsuite/ChangeLog: + + PR target/106828 + * g++.target/loongarch/pr106828.C: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 13 +++++++++++++ + gcc/testsuite/g++.target/loongarch/pr106828.C | 4 ++++ + 2 files changed, 17 insertions(+) + create mode 100644 gcc/testsuite/g++.target/loongarch/pr106828.C + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index c9187bf81..98c0e26cd 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -6466,6 +6466,16 @@ loongarch_use_anchors_for_symbol_p (const_rtx symbol) + return default_use_anchors_for_symbol_p (symbol); + } + ++/* Implement the TARGET_ASAN_SHADOW_OFFSET hook. */ ++ ++static unsigned HOST_WIDE_INT ++loongarch_asan_shadow_offset (void) ++{ ++ /* We only have libsanitizer support for LOONGARCH64 at present. ++ This value is taken from the file libsanitizer/asan/asan_mappint.h. */ ++ return TARGET_64BIT ? (HOST_WIDE_INT_1 << 46) : 0; ++} ++ + /* Initialize the GCC target structure. */ + #undef TARGET_ASM_ALIGNED_HI_OP + #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t" +@@ -6660,6 +6670,9 @@ loongarch_use_anchors_for_symbol_p (const_rtx symbol) + #undef TARGET_USE_ANCHORS_FOR_SYMBOL_P + #define TARGET_USE_ANCHORS_FOR_SYMBOL_P loongarch_use_anchors_for_symbol_p + ++#undef TARGET_ASAN_SHADOW_OFFSET ++#define TARGET_ASAN_SHADOW_OFFSET loongarch_asan_shadow_offset ++ + struct gcc_target targetm = TARGET_INITIALIZER; + + #include "gt-loongarch.h" +diff --git a/gcc/testsuite/g++.target/loongarch/pr106828.C b/gcc/testsuite/g++.target/loongarch/pr106828.C +new file mode 100644 +index 000000000..190c1db71 +--- /dev/null ++++ b/gcc/testsuite/g++.target/loongarch/pr106828.C +@@ -0,0 +1,4 @@ ++/* { dg-do-preprocess } */ ++/* { dg-options "-mabi=lp64d -fsanitize=address" } */ ++ ++/* Tests whether the compiler supports compile option '-fsanitize=address'. */ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fix-unintentional-bash-ism-in-r14-3665.patch
Added
@@ -0,0 +1,31 @@ +From 8e5c9f349877af07dde4804974d47625c1292956 Mon Sep 17 00:00:00 2001 +From: Yang Yujie <yangyujie@loongson.cn> +Date: Wed, 6 Sep 2023 17:57:47 +0800 +Subject: PATCH 070/124 LoongArch: Fix unintentional bash-ism in r14-3665. + +gcc/ChangeLog: + + * config.gcc: remove non-POSIX syntax "<<<". + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config.gcc | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/config.gcc b/gcc/config.gcc +index 19f584344..57e724080 100644 +--- a/gcc/config.gcc ++++ b/gcc/config.gcc +@@ -5263,7 +5263,7 @@ case "${target}" in + if test x${parse_state} = x"abi-base"; then + # Base ABI type + case ${component} in +- lp64d | lp64f | lp64s) elem_tmp="ABI_BASE_$(tr a-z A-Z <<< ${component}),";; ++ lp64d | lp64f | lp64s) elem_tmp="ABI_BASE_$(echo ${component} | tr a-z A-Z),";; + *) + echo "Unknown base ABI \"${component}\" in --with-multilib-list." 1>&2 + exit 1 +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fix-unintentionally-breakage-in-r14-3665.patch
Added
@@ -0,0 +1,34 @@ +From 8de6f5e1aad2a1ff85ff3a4b732055d625c61139 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 5 Sep 2023 20:02:51 +0800 +Subject: PATCH 067/124 LoongArch: Fix unintentionally breakage in r14-3665 + +Fix a build failure with no system assembler or system old assembler. + +gcc/ChangeLog: + + * config/loongarch/loongarch-opts.h (HAVE_AS_EXPLICIT_RELOCS): + Define to 0 if not defined yet. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-opts.h | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/gcc/config/loongarch/loongarch-opts.h b/gcc/config/loongarch/loongarch-opts.h +index e3f9b6f99..0d148e43b 100644 +--- a/gcc/config/loongarch/loongarch-opts.h ++++ b/gcc/config/loongarch/loongarch-opts.h +@@ -93,4 +93,8 @@ loongarch_update_gcc_opt_status (struct loongarch_target *target, + while -mno-memcpy imposes a global constraint. */ + #define TARGET_DO_OPTIMIZE_BLOCK_MOVE_P loongarch_do_optimize_block_move_p() + ++#ifndef HAVE_AS_EXPLICIT_RELOCS ++#define HAVE_AS_EXPLICIT_RELOCS 0 ++#endif ++ + #endif /* LOONGARCH_OPTS_H */ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fix-up-memcpy-vec-3.c-test-case.patch
Added
@@ -0,0 +1,33 @@ +From 78896e68f50164af7827e8da01a7220764d1e296 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Sat, 9 Sep 2023 16:18:06 +0800 +Subject: PATCH 075/124 LoongArch: Fix up memcpy-vec-3.c test case + +The generic code will split 16-byte copy into two 8-byte copies, so the +vector code wouldn't be used even if -mno-strict-align. This +contradicted with the purpose of this test case. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/memcpy-vec-3.c: Increase the amount of + copied bytes to 32. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c +index 233ed2150..db2ea510b 100644 +--- a/gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c ++++ b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c +@@ -3,4 +3,4 @@ + /* { dg-final { scan-assembler-not "vst" } } */ + + extern char a, b; +-void test() { __builtin_memcpy(a, b, 16); } ++void test() { __builtin_memcpy(a, b, 32); } +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fixed-a-bug-in-the-loongarch-architecture-.patch
Added
@@ -0,0 +1,43 @@ +From 80ed9ab39d9b1b08ad9d054f16d65b2a249a89e5 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Wed, 12 Oct 2022 11:02:11 +0800 +Subject: PATCH 022/124 LoongArch: Fixed a bug in the loongarch architecture + of libitm package. + +Add a soft floating point condition to the register recovery part of the code. + +libitm/ChangeLog: + + * config/loongarch/sjlj.S: Add a soft floating point condition to the + register recovery part of the code. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + libitm/config/loongarch/sjlj.S | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/libitm/config/loongarch/sjlj.S b/libitm/config/loongarch/sjlj.S +index a5f9fadde..f896e400e 100644 +--- a/libitm/config/loongarch/sjlj.S ++++ b/libitm/config/loongarch/sjlj.S +@@ -104,6 +104,8 @@ GTM_longjmp: + GPR_L $s7, $r5, 10*SZ_GPR + GPR_L $s8, $r5, 11*SZ_GPR + ++#if !defined(__loongarch_soft_float) ++ /* Callee-saved scratch FPRs (f24-f31) */ + FPR_L $f24, $r5, 12*SZ_GPR + 0*SZ_FPR + FPR_L $f25, $r5, 12*SZ_GPR + 1*SZ_FPR + FPR_L $f26, $r5, 12*SZ_GPR + 2*SZ_FPR +@@ -112,6 +114,7 @@ GTM_longjmp: + FPR_L $f29, $r5, 12*SZ_GPR + 5*SZ_FPR + FPR_L $f30, $r5, 12*SZ_GPR + 6*SZ_FPR + FPR_L $f31, $r5, 12*SZ_GPR + 7*SZ_FPR ++#endif + + GPR_L $r7, $r5, 2*SZ_GPR + GPR_L $fp, $r5, 0*SZ_GPR +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fixed-a-compilation-failure-with-c-in-inli.patch
Added
@@ -0,0 +1,182 @@ +From 49a63dbaf3b4296f0b1f8a0e11790cc3455aeec7 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Wed, 18 Jan 2023 11:06:56 +0800 +Subject: PATCH 034/124 LoongArch: Fixed a compilation failure with '%c' in + inline assembly PR107731. + +Co-authored-by: Yang Yujie <yangyujie@loongson.cn> + + PR target/107731 + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_classify_address): + Add precessint for CONST_INT. + (loongarch_print_operand_reloc): Operand modifier 'c' is supported. + (loongarch_print_operand): Increase the processing of '%c'. + * doc/extend.texi: Adds documents for LoongArch operand modifiers. + And port the public operand modifiers information to this document. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/tst-asm-const.c: Moved to... + * gcc.target/loongarch/pr107731.c: ...here. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 14 +++++ + gcc/doc/extend.texi | 51 +++++++++++++++++-- + .../loongarch/{tst-asm-const.c => pr107731.c} | 6 +-- + 3 files changed, 64 insertions(+), 7 deletions(-) + rename gcc/testsuite/gcc.target/loongarch/{tst-asm-const.c => pr107731.c} (78%) + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index e59edc4cd..1a4686f03 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -2074,6 +2074,11 @@ loongarch_classify_address (struct loongarch_address_info *info, rtx x, + return (loongarch_valid_base_register_p (info->reg, mode, strict_p) + && loongarch_valid_lo_sum_p (info->symbol_type, mode, + info->offset)); ++ case CONST_INT: ++ /* Small-integer addresses don't occur very often, but they ++ are legitimate if $r0 is a valid base register. */ ++ info->type = ADDRESS_CONST_INT; ++ return IMM12_OPERAND (INTVAL (x)); + + default: + return false; +@@ -4932,6 +4937,7 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part, + + 'A' Print a _DB suffix if the memory model requires a release. + 'b' Print the address of a memory operand, without offset. ++ 'c' Print an integer. + 'C' Print the integer branch condition for comparison OP. + 'd' Print CONST_INT OP in decimal. + 'F' Print the FPU branch condition for comparison OP. +@@ -4978,6 +4984,14 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + fputs ("_db", file); + break; + ++ case 'c': ++ if (CONST_INT_P (op)) ++ fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (op)); ++ else ++ output_operand_lossage ("unsupported operand for code '%c'", letter); ++ ++ break; ++ + case 'C': + loongarch_print_int_branch_condition (file, code, letter); + break; +diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi +index da2840c23..3c101ca89 100644 +--- a/gcc/doc/extend.texi ++++ b/gcc/doc/extend.texi +@@ -10414,8 +10414,10 @@ ensures that modifying @var{a} does not affect the address referenced by + is undefined if @var{a} is modified before using @var{b}. + + @code{asm} supports operand modifiers on operands (for example @samp{%k2} +-instead of simply @samp{%2}). Typically these qualifiers are hardware +-dependent. The list of supported modifiers for x86 is found at ++instead of simply @samp{%2}). @ref{GenericOperandmodifiers, ++Generic Operand modifiers} lists the modifiers that are available ++on all targets. Other modifiers are hardware dependent. ++For example, the list of supported modifiers for x86 is found at + @ref{x86Operandmodifiers,x86 Operand modifiers}. + + If the C code that follows the @code{asm} makes no use of any of the output +@@ -10683,8 +10685,10 @@ optimizers may discard the @code{asm} statement as unneeded + (see @ref{Volatile}). + + @code{asm} supports operand modifiers on operands (for example @samp{%k2} +-instead of simply @samp{%2}). Typically these qualifiers are hardware +-dependent. The list of supported modifiers for x86 is found at ++instead of simply @samp{%2}). @ref{GenericOperandmodifiers, ++Generic Operand modifiers} lists the modifiers that are available ++on all targets. Other modifiers are hardware dependent. ++For example, the list of supported modifiers for x86 is found at + @ref{x86Operandmodifiers,x86 Operand modifiers}. + + In this example using the fictitious @code{combine} instruction, the +@@ -11036,6 +11040,30 @@ lab: + @} + @end example + ++@anchor{GenericOperandmodifiers} ++@subsubsection Generic Operand Modifiers ++@noindent ++The following table shows the modifiers supported by all targets and their effects: ++ ++@multitable {Modifier} {Description} {Example} ++@headitem Modifier @tab Description @tab Example ++@item @code{c} ++@tab Require a constant operand and print the constant expression with no punctuation. ++@tab @code{%c0} ++@item @code{n} ++@tab Like @samp{%c} except that the value of the constant is negated before printing. ++@tab @code{%n0} ++@item @code{a} ++@tab Substitute a memory reference, with the actual operand treated as the address. ++This may be useful when outputting a ``load address'' instruction, because ++often the assembler syntax for such an instruction requires you to write the ++operand as if it were a memory reference. ++@tab @code{%a0} ++@item @code{l} ++@tab Print the label name with no punctuation. ++@tab @code{%l0} ++@end multitable ++ + @anchor{x86Operandmodifiers} + @subsubsection x86 Operand Modifiers + +@@ -11386,6 +11414,21 @@ constant. Used to select the specified bit position. + @item @code{x} @tab Equivialent to @code{X}, but only for pointers. + @end multitable + ++@anchor{loongarchOperandmodifiers} ++@subsubsection LoongArch Operand Modifiers ++ ++The list below describes the supported modifiers and their effects for LoongArch. ++ ++@multitable @columnfractions .10 .90 ++@headitem Modifier @tab Description ++@item @code{d} @tab Same as @code{c}. ++@item @code{i} @tab Print the character ''@code{i}'' if the operand is not a register. ++@item @code{m} @tab Same as @code{c}, but the printed value is @code{operand - 1}. ++@item @code{X} @tab Print a constant integer operand in hexadecimal. ++@item @code{z} @tab Print the operand in its unmodified form, followed by a comma. ++@end multitable ++ ++ + @lowersections + @include md.texi + @raisesections +diff --git a/gcc/testsuite/gcc.target/loongarch/tst-asm-const.c b/gcc/testsuite/gcc.target/loongarch/pr107731.c +similarity index 78% +rename from gcc/testsuite/gcc.target/loongarch/tst-asm-const.c +rename to gcc/testsuite/gcc.target/loongarch/pr107731.c +index 2e04b99e3..80d84c48c 100644 +--- a/gcc/testsuite/gcc.target/loongarch/tst-asm-const.c ++++ b/gcc/testsuite/gcc.target/loongarch/pr107731.c +@@ -1,13 +1,13 @@ +-/* Test asm const. */ + /* { dg-do compile } */ + /* { dg-final { scan-assembler-times "foo:.*\\.long 1061109567.*\\.long 52" 1 } } */ ++ + int foo () + { + __asm__ volatile ( + "foo:" + "\n\t" +- ".long %a0\n\t" +- ".long %a1\n\t" ++ ".long %c0\n\t" ++ ".long %c1\n\t" + : + :"i"(0x3f3f3f3f), "i"(52) + : +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Fixed-a-typo-in-the-comment-information-of.patch
Added
@@ -0,0 +1,33 @@ +From cbb5f181544e35b119fee4ed150bec24eee7179c Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Wed, 28 Sep 2022 16:35:06 +0800 +Subject: PATCH 020/124 LoongArch: Fixed a typo in the comment information of + the function loongarch_asan_shadow_offset. + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_asan_shadow_offset): + Fixed typo in "asan_mapping.h". + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 98c0e26cd..e9ba3374e 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -6472,7 +6472,7 @@ static unsigned HOST_WIDE_INT + loongarch_asan_shadow_offset (void) + { + /* We only have libsanitizer support for LOONGARCH64 at present. +- This value is taken from the file libsanitizer/asan/asan_mappint.h. */ ++ This value is taken from the file libsanitizer/asan/asan_mapping.h. */ + return TARGET_64BIT ? (HOST_WIDE_INT_1 << 46) : 0; + } + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Generate-bytepick.-wd-for-suitable-bit-ope.patch
Added
@@ -0,0 +1,196 @@ +From 9311c0f56086e38fe5e9bf4bbfc2e37d0f18347c Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Fri, 3 Feb 2023 17:06:06 +0800 +Subject: PATCH 036/124 LoongArch: Generate bytepick.wd for suitable bit + operation pattern + +We can use bytepick.wd for + + a << (8 * x) | b >> (8 * (sizeof(a) - x)) + +while a and b are uint32_t or uint64_t. This is useful for some cases, +for example: +https://sourceware.org/pipermail/libc-alpha/2023-February/145203.html + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (bytepick_w_ashift_amount): + New define_int_iterator. + (bytepick_d_ashift_amount): Likewise. + (bytepick_imm): New define_int_attr. + (bytepick_w_lshiftrt_amount): Likewise. + (bytepick_d_lshiftrt_amount): Likewise. + (bytepick_w_<bytepick_imm>): New define_insn template. + (bytepick_w_<bytepick_imm>_extend): Likewise. + (bytepick_d_<bytepick_imm>): Likewise. + (bytepick_w): Remove unused define_insn. + (bytepick_d): Likewise. + (UNSPEC_BYTEPICK_W): Remove unused unspec. + (UNSPEC_BYTEPICK_D): Likewise. + * config/loongarch/predicates.md (const_0_to_3_operand): + Remove unused define_predicate. + (const_0_to_7_operand): Likewise. + +gcc/testsuite/ChangeLog: + + * g++.target/loongarch/bytepick.C: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 60 ++++++++++++++----- + gcc/config/loongarch/predicates.md | 8 --- + gcc/testsuite/g++.target/loongarch/bytepick.C | 32 ++++++++++ + 3 files changed, 77 insertions(+), 23 deletions(-) + create mode 100644 gcc/testsuite/g++.target/loongarch/bytepick.C + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index f61db66d5..833b94753 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -48,8 +48,6 @@ + UNSPEC_EH_RETURN + + ;; Bit operation +- UNSPEC_BYTEPICK_W +- UNSPEC_BYTEPICK_D + UNSPEC_BITREV_4B + UNSPEC_BITREV_8B + +@@ -544,6 +542,27 @@ + (UNSPEC_FTINTRM "0") + (UNSPEC_FTINTRP "0")) + ++;; Iterator and attributes for bytepick.d ++(define_int_iterator bytepick_w_ashift_amount 8 16 24) ++(define_int_attr bytepick_w_lshiftrt_amount (8 "24") ++ (16 "16") ++ (24 "8")) ++(define_int_iterator bytepick_d_ashift_amount 8 16 24 32 40 48 56) ++(define_int_attr bytepick_d_lshiftrt_amount (8 "56") ++ (16 "48") ++ (24 "40") ++ (32 "32") ++ (40 "24") ++ (48 "16") ++ (56 "8")) ++(define_int_attr bytepick_imm (8 "1") ++ (16 "2") ++ (24 "3") ++ (32 "4") ++ (40 "5") ++ (48 "6") ++ (56 "7")) ++ + ;; + ;; .................... + ;; +@@ -3364,24 +3383,35 @@ + (set_attr "type" "unknown") + (set_attr "mode" "<MODE>")) + +-(define_insn "bytepick_w" ++(define_insn "bytepick_w_<bytepick_imm>" + (set (match_operand:SI 0 "register_operand" "=r") +- (unspec:SI (match_operand:SI 1 "register_operand" "r") +- (match_operand:SI 2 "register_operand" "r") +- (match_operand:SI 3 "const_0_to_3_operand" "n") +- UNSPEC_BYTEPICK_W)) ++ (ior:SI (lshiftrt (match_operand:SI 1 "register_operand" "r") ++ (const_int <bytepick_w_lshiftrt_amount>)) ++ (ashift (match_operand:SI 2 "register_operand" "r") ++ (const_int bytepick_w_ashift_amount)))) + "" +- "bytepick.w\t%0,%1,%2,%z3" ++ "bytepick.w\t%0,%1,%2,<bytepick_imm>" + (set_attr "mode" "SI")) + +-(define_insn "bytepick_d" ++(define_insn "bytepick_w_<bytepick_imm>_extend" + (set (match_operand:DI 0 "register_operand" "=r") +- (unspec:DI (match_operand:DI 1 "register_operand" "r") +- (match_operand:DI 2 "register_operand" "r") +- (match_operand:DI 3 "const_0_to_7_operand" "n") +- UNSPEC_BYTEPICK_D)) +- "" +- "bytepick.d\t%0,%1,%2,%z3" ++ (sign_extend:DI ++ (ior:SI (lshiftrt (match_operand:SI 1 "register_operand" "r") ++ (const_int <bytepick_w_lshiftrt_amount>)) ++ (ashift (match_operand:SI 2 "register_operand" "r") ++ (const_int bytepick_w_ashift_amount))))) ++ "TARGET_64BIT" ++ "bytepick.w\t%0,%1,%2,<bytepick_imm>" ++ (set_attr "mode" "SI")) ++ ++(define_insn "bytepick_d_<bytepick_imm>" ++ (set (match_operand:DI 0 "register_operand" "=r") ++ (ior:DI (lshiftrt (match_operand:DI 1 "register_operand" "r") ++ (const_int <bytepick_d_lshiftrt_amount>)) ++ (ashift (match_operand:DI 2 "register_operand" "r") ++ (const_int bytepick_d_ashift_amount)))) ++ "TARGET_64BIT" ++ "bytepick.d\t%0,%1,%2,<bytepick_imm>" + (set_attr "mode" "DI")) + + (define_insn "bitrev_4b" +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index 58c3dc226..3c32b2987 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -91,14 +91,6 @@ + (ior (match_operand 0 "const_1_operand") + (match_operand 0 "register_operand"))) + +-(define_predicate "const_0_to_3_operand" +- (and (match_code "const_int") +- (match_test "IN_RANGE (INTVAL (op), 0, 3)"))) +- +-(define_predicate "const_0_to_7_operand" +- (and (match_code "const_int") +- (match_test "IN_RANGE (INTVAL (op), 0, 7)"))) +- + (define_predicate "lu52i_mask_operand" + (and (match_code "const_int") + (match_test "UINTVAL (op) == 0xfffffffffffff"))) +diff --git a/gcc/testsuite/g++.target/loongarch/bytepick.C b/gcc/testsuite/g++.target/loongarch/bytepick.C +new file mode 100644 +index 000000000..a39e2fa65 +--- /dev/null ++++ b/gcc/testsuite/g++.target/loongarch/bytepick.C +@@ -0,0 +1,32 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d" } */ ++/* { dg-final { scan-assembler-times "bytepick.w\t\\\$r4,\\\$r5,\\\$r4" 3 } } */ ++/* { dg-final { scan-assembler-times "bytepick.d\t\\\$r4,\\\$r5,\\\$r4" 7 } } */ ++/* { dg-final { scan-assembler-not "slli.w" } } */ ++ ++template <class T, int offs> ++T ++merge (T a, T b) ++{ ++ return a << offs | b >> (8 * sizeof (T) - offs); ++} ++ ++using u32 = __UINT32_TYPE__; ++using u64 = __UINT64_TYPE__; ++using i64 = __INT64_TYPE__; ++ ++template u32 merge<u32, 8> (u32, u32); ++template u32 merge<u32, 16> (u32, u32); ++template u32 merge<u32, 24> (u32, u32); ++ ++template u64 merge<u64, 8> (u64, u64); ++template u64 merge<u64, 16> (u64, u64); ++template u64 merge<u64, 24> (u64, u64); ++template u64 merge<u64, 32> (u64, u64); ++template u64 merge<u64, 40> (u64, u64); ++template u64 merge<u64, 48> (u64, u64); ++template u64 merge<u64, 56> (u64, u64); ++ ++/* we cannot use bytepick for the following cases */ ++template i64 merge<i64, 8> (i64, i64); ++template u64 merge<u64, 42> (u64, u64); +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Get-__tls_get_addr-address-through-got-tab.patch
Added
@@ -0,0 +1,71 @@ +From a96dee6ba3c916f9a4329b196a0c5a1652fe294f Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 18 Aug 2022 09:57:14 +0800 +Subject: PATCH 010/124 LoongArch: Get __tls_get_addr address through got + table when disable plt. + +Fix bug, ICE with tls gd/ld var with -fno-plt. + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_call_tls_get_addr): + Get __tls_get_addr address through got table when disable plt. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/tls-gd-noplt.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 14 ++++++++++++-- + gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c | 12 ++++++++++++ + 2 files changed, 24 insertions(+), 2 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 1b5af2c7d..76bf55ea4 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -2448,8 +2448,18 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + gcc_unreachable (); + } + +- insn = emit_call_insn (gen_call_value_internal (v0, loongarch_tls_symbol, +- const0_rtx)); ++ if (flag_plt) ++ insn = emit_call_insn (gen_call_value_internal (v0, loongarch_tls_symbol, ++ const0_rtx)); ++ else ++ { ++ rtx dest = gen_reg_rtx (Pmode); ++ rtx high = gen_reg_rtx (Pmode); ++ loongarch_emit_move (high, gen_rtx_HIGH (Pmode, loongarch_tls_symbol)); ++ emit_insn (gen_ld_from_got (Pmode, dest, high, loongarch_tls_symbol)); ++ insn = emit_call_insn (gen_call_value_internal (v0, dest, const0_rtx)); ++ } ++ + RTL_CONST_CALL_P (insn) = 1; + use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0); + insn = get_insns (); +diff --git a/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c b/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c +new file mode 100644 +index 000000000..32a0acf9b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fno-plt -mcmodel=normal" } */ ++/* { dg-final { scan-assembler "pcalau12i\t.*%got_pc_hi20\\(__tls_get_addr\\)" } } */ ++ ++__attribute__ ((tls_model ("global-dynamic"))) __thread int a; ++ ++void ++test (void) ++{ ++ a = 10; ++} ++ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Implement-128-bit-floating-point-functions.patch
Added
@@ -0,0 +1,204 @@ +From 12ab9eae9e8a5b83c778182f15c6216bcbc3dc36 Mon Sep 17 00:00:00 2001 +From: chenxiaolong <chenxiaolong@loongson.cn> +Date: Fri, 1 Sep 2023 11:22:42 +0800 +Subject: PATCH 054/124 LoongArch: Implement 128-bit floating point functions + in gcc. + +During implementation, float128_type_node is bound with the type "__float128" +so that the compiler can correctly identify the type of the function. The +"q" suffix is associated with the "f128" function, which makes GCC more +flexible to support different user input cases, implementing functions such +as __builtin_{huge_valq, infq, fabsq, copysignq, nanq, nansq}. + +gcc/ChangeLog: + + * config/loongarch/loongarch-builtins.cc (loongarch_init_builtins): + Associate the __float128 type to float128_type_node so that it can + be recognized by the compiler. + * config/loongarch/loongarch-c.cc (loongarch_cpu_cpp_builtins): + Add the flag "FLOAT128_TYPE" to gcc and associate a function + with the suffix "q" to "f128". + * doc/extend.texi:Added support for 128-bit floating-point functions on + the LoongArch architecture. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/math-float-128.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-builtins.cc | 5 ++ + gcc/config/loongarch/loongarch-c.cc | 11 +++ + gcc/doc/extend.texi | 20 ++++- + .../gcc.target/loongarch/math-float-128.c | 81 +++++++++++++++++++ + 4 files changed, 114 insertions(+), 3 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/math-float-128.c + +diff --git a/gcc/config/loongarch/loongarch-builtins.cc b/gcc/config/loongarch/loongarch-builtins.cc +index 64fe11168..cb0ea1664 100644 +--- a/gcc/config/loongarch/loongarch-builtins.cc ++++ b/gcc/config/loongarch/loongarch-builtins.cc +@@ -256,6 +256,11 @@ loongarch_init_builtins (void) + unsigned int i; + tree type; + ++ /* Register the type float128_type_node as a built-in type and ++ give it an alias "__float128". */ ++ (*lang_hooks.types.register_builtin_type) (float128_type_node, ++ "__float128"); ++ + /* Iterate through all of the bdesc arrays, initializing all of the + builtin functions. */ + for (i = 0; i < ARRAY_SIZE (loongarch_builtins); i++) +diff --git a/gcc/config/loongarch/loongarch-c.cc b/gcc/config/loongarch/loongarch-c.cc +index d6e3e19f0..f779a7355 100644 +--- a/gcc/config/loongarch/loongarch-c.cc ++++ b/gcc/config/loongarch/loongarch-c.cc +@@ -99,6 +99,17 @@ loongarch_cpu_cpp_builtins (cpp_reader *pfile) + else + builtin_define ("__loongarch_frlen=0"); + ++ /* Add support for FLOAT128_TYPE on the LoongArch architecture. */ ++ builtin_define ("__FLOAT128_TYPE__"); ++ ++ /* Map the old _Float128 'q' builtins into the new 'f128' builtins. */ ++ builtin_define ("__builtin_fabsq=__builtin_fabsf128"); ++ builtin_define ("__builtin_copysignq=__builtin_copysignf128"); ++ builtin_define ("__builtin_nanq=__builtin_nanf128"); ++ builtin_define ("__builtin_nansq=__builtin_nansf128"); ++ builtin_define ("__builtin_infq=__builtin_inff128"); ++ builtin_define ("__builtin_huge_valq=__builtin_huge_valf128"); ++ + /* Native Data Sizes. */ + builtin_define_with_int_value ("_LOONGARCH_SZINT", INT_TYPE_SIZE); + builtin_define_with_int_value ("_LOONGARCH_SZLONG", LONG_TYPE_SIZE); +diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi +index 1d1bac255..bb19d0f27 100644 +--- a/gcc/doc/extend.texi ++++ b/gcc/doc/extend.texi +@@ -1085,10 +1085,10 @@ types. + As an extension, GNU C and GNU C++ support additional floating + types, which are not supported by all targets. + @itemize @bullet +-@item @code{__float128} is available on i386, x86_64, IA-64, and +-hppa HP-UX, as well as on PowerPC GNU/Linux targets that enable ++@item @code{__float128} is available on i386, x86_64, IA-64, LoongArch ++and hppa HP-UX, as well as on PowerPC GNU/Linux targets that enable + the vector scalar (VSX) instruction set. @code{__float128} supports +-the 128-bit floating type. On i386, x86_64, PowerPC, and IA-64 ++the 128-bit floating type. On i386, x86_64, PowerPC, LoongArch and IA-64, + other than HP-UX, @code{__float128} is an alias for @code{_Float128}. + On hppa and IA-64 HP-UX, @code{__float128} is an alias for @code{long + double}. +@@ -16257,6 +16257,20 @@ function you need to include @code{larchintrin.h}. + void __break (imm0_32767) + @end smallexample + ++Additional built-in functions are available for LoongArch family ++processors to efficiently use 128-bit floating-point (__float128) ++values. ++ ++The following are the basic built-in functions supported. ++@smallexample ++__float128 __builtin_fabsq (__float128); ++__float128 __builtin_copysignq (__float128, __float128); ++__float128 __builtin_infq (void); ++__float128 __builtin_huge_valq (void); ++__float128 __builtin_nanq (void); ++__float128 __builtin_nansq (void); ++@end smallexample ++ + @node MIPS DSP Built-in Functions + @subsection MIPS DSP Built-in Functions + +diff --git a/gcc/testsuite/gcc.target/loongarch/math-float-128.c b/gcc/testsuite/gcc.target/loongarch/math-float-128.c +new file mode 100644 +index 000000000..387566a57 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/math-float-128.c +@@ -0,0 +1,81 @@ ++/* { dg-do compile } */ ++/* { dg-options " -march=loongarch64 -O2 " } */ ++/* { dg-final { scan-assembler-not "my_fabsq2:.*\\bl\t%plt\\(__builtin_fabsq\\).*my_fabsq2" } } */ ++/* { dg-final { scan-assembler-not "my_copysignq2:.*\\bl\t%plt\\(__builtin_copysignq\\).*my_copysignq2" } } */ ++/* { dg-final { scan-assembler-not "my_infq2:.*\\bl\t%plt\\(__builtin_infq\\).*my_infq2" } } */ ++/* { dg-final { scan-assembler-not "my_huge_valq2:.*\\bl\t%plt\\(__builtin_huge_valq\\).*my_huge_valq2" } } */ ++/* { dg-final { scan-assembler-not "my_nanq2:.*\\bl\t%plt\\(__builtin_nanq\\).*my_nanq2" } } */ ++/* { dg-final { scan-assembler-not "my_nansq2:.*\\bl\t%plt\\(__builtin_nansq\\).*my_nansq2" } } */ ++ ++__float128 ++my_fabsq1 (__float128 a) ++{ ++ return __builtin_fabsq (a); ++} ++ ++_Float128 ++my_fabsq2 (_Float128 a) ++{ ++ return __builtin_fabsq (a); ++} ++ ++__float128 ++my_copysignq1 (__float128 a, __float128 b) ++{ ++ return __builtin_copysignq (a, b); ++} ++ ++_Float128 ++my_copysignq2 (_Float128 a, _Float128 b) ++{ ++ return __builtin_copysignq (a, b); ++} ++ ++__float128 ++my_infq1 (void) ++{ ++ return __builtin_infq (); ++} ++ ++_Float128 ++my_infq2 (void) ++{ ++ return __builtin_infq (); ++} ++ ++__float128 ++my_huge_valq1 (void) ++{ ++ return __builtin_huge_valq (); ++} ++ ++_Float128 ++my_huge_valq2 (void) ++{ ++ return __builtin_huge_valq (); ++} ++ ++__float128 ++my_nanq1 (void) ++{ ++ return __builtin_nanq (""); ++} ++ ++_Float128 ++my_nanq2 (void) ++{ ++ return __builtin_nanq (""); ++} ++ ++__float128 ++my_nansq1 (void) ++{ ++ return __builtin_nansq (""); ++} ++ ++_Float128 ++my_nansq2 (void) ++{ ++ return __builtin_nansq (""); ++} ++ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Improve-GAR-store-for-va_list.patch
Added
@@ -0,0 +1,83 @@ +From 4075f299ca6a5d15fdb46f877cbe11b7166a19ff Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 29 Mar 2023 01:36:09 +0800 +Subject: PATCH 042/124 LoongArch: Improve GAR store for va_list + +LoongArch backend used to save all GARs for a function with variable +arguments. But sometimes a function only accepts variable arguments for +a purpose like C++ function overloading. For example, POSIX defines +open() as: + + int open(const char *path, int oflag, ...); + +But only two forms are actually used: + + int open(const char *pathname, int flags); + int open(const char *pathname, int flags, mode_t mode); + +So it's obviously a waste to save all 8 GARs in open(). We can use the +cfun->va_list_gpr_size field set by the stdarg pass to only save the +GARs necessary to be saved. + +If the va_list escapes (for example, in fprintf() we pass it to +vfprintf()), stdarg would set cfun->va_list_gpr_size to 255 so we +don't need a special case. + +With this patch, only one GAR ($a2/$r6) is saved in open(). Ideally +even this stack store should be omitted too, but doing so is not trivial +and AFAIK there are no compilers (for any target) performing the "ideal" +optimization here, see https://godbolt.org/z/n1YqWq9c9. + +Bootstrapped and regtested on loongarch64-linux-gnu. Ok for trunk +(GCC 14 or now)? + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc + (loongarch_setup_incoming_varargs): Don't save more GARs than + cfun->va_list_gpr_size / UNITS_PER_WORD. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/va_arg.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/testsuite/gcc.target/loongarch/va_arg.c | 24 +++++++++++++++++++++ + 1 file changed, 24 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/va_arg.c + +diff --git a/gcc/testsuite/gcc.target/loongarch/va_arg.c b/gcc/testsuite/gcc.target/loongarch/va_arg.c +new file mode 100644 +index 000000000..980c96d0e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/va_arg.c +@@ -0,0 +1,24 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++ ++/* Technically we shouldn't save any register for this function: it should be ++ compiled as if it accepts 3 named arguments. But AFAIK no compilers can ++ achieve this "perfect" optimization now, so just ensure we are using the ++ knowledge provided by stdarg pass and we won't save GARs impossible to be ++ accessed with __builtin_va_arg () when the va_list does not escape. */ ++ ++/* { dg-final { scan-assembler-not "st.*r7" } } */ ++ ++int ++test (int a0, ...) ++{ ++ void *arg; ++ int a1, a2; ++ ++ __builtin_va_start (arg, a0); ++ a1 = __builtin_va_arg (arg, int); ++ a2 = __builtin_va_arg (arg, int); ++ __builtin_va_end (arg); ++ ++ return a0 + a1 + a2; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Improve-cpymemsi-expansion-PR109465.patch
Added
@@ -0,0 +1,339 @@ +From 33fff578e7df7aa7e236efc6c9c85c595918d86a Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 12 Apr 2023 11:45:48 +0000 +Subject: PATCH 043/124 LoongArch: Improve cpymemsi expansion PR109465 + +We'd been generating really bad block move sequences which is recently +complained by kernel developers who tried __builtin_memcpy. To improve +it: + +1. Take the advantage of -mno-strict-align. When it is set, set mode + size to UNITS_PER_WORD regardless of the alignment. +2. Half the mode size when (block size) % (mode size) != 0, instead of + falling back to ld.bu/st.b at once. +3. Limit the length of block move sequence considering the number of + instructions, not the size of block. When -mstrict-align is set and + the block is not aligned, the old size limit for straight-line + implementation (64 bytes) was definitely too large (we don't have 64 + registers anyway). + +Change since v1: add a comment about the calculation of num_reg. + +gcc/ChangeLog: + + PR target/109465 + * config/loongarch/loongarch-protos.h + (loongarch_expand_block_move): Add a parameter as alignment RTX. + * config/loongarch/loongarch.h: + (LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER): Remove. + (LARCH_MAX_MOVE_BYTES_STRAIGHT): Remove. + (LARCH_MAX_MOVE_OPS_PER_LOOP_ITER): Define. + (LARCH_MAX_MOVE_OPS_STRAIGHT): Define. + (MOVE_RATIO): Use LARCH_MAX_MOVE_OPS_PER_LOOP_ITER instead of + LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER. + * config/loongarch/loongarch.cc (loongarch_expand_block_move): + Take the alignment from the parameter, but set it to + UNITS_PER_WORD if !TARGET_STRICT_ALIGN. Limit the length of + straight-line implementation with LARCH_MAX_MOVE_OPS_STRAIGHT + instead of LARCH_MAX_MOVE_BYTES_STRAIGHT. + (loongarch_block_move_straight): When there are left-over bytes, + half the mode size instead of falling back to byte mode at once. + (loongarch_block_move_loop): Limit the length of loop body with + LARCH_MAX_MOVE_OPS_PER_LOOP_ITER instead of + LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER. + * config/loongarch/loongarch.md (cpymemsi): Pass the alignment + to loongarch_expand_block_move. + +gcc/testsuite/ChangeLog: + + PR target/109465 + * gcc.target/loongarch/pr109465-1.c: New test. + * gcc.target/loongarch/pr109465-2.c: New test. + * gcc.target/loongarch/pr109465-3.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-protos.h | 2 +- + gcc/config/loongarch/loongarch.cc | 95 +++++++++++-------- + gcc/config/loongarch/loongarch.h | 10 +- + gcc/config/loongarch/loongarch.md | 3 +- + .../gcc.target/loongarch/pr109465-1.c | 9 ++ + .../gcc.target/loongarch/pr109465-2.c | 9 ++ + .../gcc.target/loongarch/pr109465-3.c | 12 +++ + 7 files changed, 91 insertions(+), 49 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/pr109465-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/pr109465-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/pr109465-3.c + +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 0a9b47722..3ac3b5e19 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -95,7 +95,7 @@ extern void loongarch_expand_conditional_trap (rtx); + #endif + extern void loongarch_set_return_address (rtx, rtx); + extern bool loongarch_move_by_pieces_p (unsigned HOST_WIDE_INT, unsigned int); +-extern bool loongarch_expand_block_move (rtx, rtx, rtx); ++extern bool loongarch_expand_block_move (rtx, rtx, rtx, rtx); + extern bool loongarch_do_optimize_block_move_p (void); + + extern bool loongarch_expand_ext_as_unaligned_load (rtx, rtx, HOST_WIDE_INT, +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 233dddbac..d3c6f22ad 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -4456,41 +4456,46 @@ loongarch_function_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED, + Assume that the areas do not overlap. */ + + static void +-loongarch_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length) ++loongarch_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length, ++ HOST_WIDE_INT delta) + { +- HOST_WIDE_INT offset, delta; +- unsigned HOST_WIDE_INT bits; ++ HOST_WIDE_INT offs, delta_cur; + int i; + machine_mode mode; + rtx *regs; + +- bits = MIN (BITS_PER_WORD, MIN (MEM_ALIGN (src), MEM_ALIGN (dest))); +- +- mode = int_mode_for_size (bits, 0).require (); +- delta = bits / BITS_PER_UNIT; ++ /* Calculate how many registers we'll need for the block move. ++ We'll emit length / delta move operations with delta as the size ++ first. Then we may still have length % delta bytes not copied. ++ We handle these remaining bytes by move operations with smaller ++ (halfed) sizes. For example, if length = 21 and delta = 8, we'll ++ emit two ld.d/st.d pairs, one ld.w/st.w pair, and one ld.b/st.b ++ pair. For each load/store pair we use a dedicated register to keep ++ the pipeline as populated as possible. */ ++ HOST_WIDE_INT num_reg = length / delta; ++ for (delta_cur = delta / 2; delta_cur != 0; delta_cur /= 2) ++ num_reg += !!(length & delta_cur); + + /* Allocate a buffer for the temporary registers. */ +- regs = XALLOCAVEC (rtx, length / delta); ++ regs = XALLOCAVEC (rtx, num_reg); + +- /* Load as many BITS-sized chunks as possible. Use a normal load if +- the source has enough alignment, otherwise use left/right pairs. */ +- for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++) ++ for (delta_cur = delta, i = 0, offs = 0; offs < length; delta_cur /= 2) + { +- regsi = gen_reg_rtx (mode); +- loongarch_emit_move (regsi, adjust_address (src, mode, offset)); +- } ++ mode = int_mode_for_size (delta_cur * BITS_PER_UNIT, 0).require (); + +- for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++) +- loongarch_emit_move (adjust_address (dest, mode, offset), regsi); ++ for (; offs + delta_cur <= length; offs += delta_cur, i++) ++ { ++ regsi = gen_reg_rtx (mode); ++ loongarch_emit_move (regsi, adjust_address (src, mode, offs)); ++ } ++ } + +- /* Mop up any left-over bytes. */ +- if (offset < length) ++ for (delta_cur = delta, i = 0, offs = 0; offs < length; delta_cur /= 2) + { +- src = adjust_address (src, BLKmode, offset); +- dest = adjust_address (dest, BLKmode, offset); +- move_by_pieces (dest, src, length - offset, +- MIN (MEM_ALIGN (src), MEM_ALIGN (dest)), +- (enum memop_ret) 0); ++ mode = int_mode_for_size (delta_cur * BITS_PER_UNIT, 0).require (); ++ ++ for (; offs + delta_cur <= length; offs += delta_cur, i++) ++ loongarch_emit_move (adjust_address (dest, mode, offs), regsi); + } + } + +@@ -4520,10 +4525,11 @@ loongarch_adjust_block_mem (rtx mem, HOST_WIDE_INT length, rtx *loop_reg, + + static void + loongarch_block_move_loop (rtx dest, rtx src, HOST_WIDE_INT length, +- HOST_WIDE_INT bytes_per_iter) ++ HOST_WIDE_INT align) + { + rtx_code_label *label; + rtx src_reg, dest_reg, final_src, test; ++ HOST_WIDE_INT bytes_per_iter = align * LARCH_MAX_MOVE_OPS_PER_LOOP_ITER; + HOST_WIDE_INT leftover; + + leftover = length % bytes_per_iter; +@@ -4543,7 +4549,7 @@ loongarch_block_move_loop (rtx dest, rtx src, HOST_WIDE_INT length, + emit_label (label); + + /* Emit the loop body. */ +- loongarch_block_move_straight (dest, src, bytes_per_iter); ++ loongarch_block_move_straight (dest, src, bytes_per_iter, align); + + /* Move on to the next block. */ + loongarch_emit_move (src_reg, +@@ -4560,7 +4566,7 @@ loongarch_block_move_loop (rtx dest, rtx src, HOST_WIDE_INT length, + + /* Mop up any left-over bytes. */ + if (leftover) +- loongarch_block_move_straight (dest, src, leftover); ++ loongarch_block_move_straight (dest, src, leftover, align); + else + /* Temporary fix for PR79150. */ + emit_insn (gen_nop ()); +@@ -4570,25 +4576,32 @@ loongarch_block_move_loop (rtx dest, rtx src, HOST_WIDE_INT length, + memory reference SRC to memory reference DEST. */ + + bool +-loongarch_expand_block_move (rtx dest, rtx src, rtx length) ++loongarch_expand_block_move (rtx dest, rtx src, rtx r_length, rtx r_align) + { +- int max_move_bytes = LARCH_MAX_MOVE_BYTES_STRAIGHT; ++ if (!CONST_INT_P (r_length)) ++ return false; ++ ++ HOST_WIDE_INT length = INTVAL (r_length); ++ if (length > loongarch_max_inline_memcpy_size) ++ return false; ++ ++ HOST_WIDE_INT align = INTVAL (r_align); ++ ++ if (!TARGET_STRICT_ALIGN || align > UNITS_PER_WORD) ++ align = UNITS_PER_WORD; + +- if (CONST_INT_P (length) +- && INTVAL (length) <= loongarch_max_inline_memcpy_size) ++ if (length <= align * LARCH_MAX_MOVE_OPS_STRAIGHT) + { +- if (INTVAL (length) <= max_move_bytes) +- { +- loongarch_block_move_straight (dest, src, INTVAL (length)); +- return true; +- } +- else if (optimize) +- { +- loongarch_block_move_loop (dest, src, INTVAL (length), +- LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER); +- return true; +- } ++ loongarch_block_move_straight (dest, src, length, align); ++ return true; ++ } ++ ++ if (optimize) ++ { ++ loongarch_block_move_loop (dest, src, length, align); ++ return true; + } ++ + return false; + } + +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index 9d3cd9ca0..af24bfa01 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -1062,13 +1062,13 @@ typedef struct { + + /* The maximum number of bytes that can be copied by one iteration of + a cpymemsi loop; see loongarch_block_move_loop. */ +-#define LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER (UNITS_PER_WORD * 4) ++#define LARCH_MAX_MOVE_OPS_PER_LOOP_ITER 4 + + /* The maximum number of bytes that can be copied by a straight-line + implementation of cpymemsi; see loongarch_block_move_straight. We want + to make sure that any loop-based implementation will iterate at + least twice. */ +-#define LARCH_MAX_MOVE_BYTES_STRAIGHT (LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER * 2) ++#define LARCH_MAX_MOVE_OPS_STRAIGHT (LARCH_MAX_MOVE_OPS_PER_LOOP_ITER * 2) + + /* The base cost of a memcpy call, for MOVE_RATIO and friends. These + values were determined experimentally by benchmarking with CSiBE. +@@ -1076,7 +1076,7 @@ typedef struct { + #define LARCH_CALL_RATIO 8 + + /* Any loop-based implementation of cpymemsi will have at least +- LARCH_MAX_MOVE_BYTES_STRAIGHT / UNITS_PER_WORD memory-to-memory ++ LARCH_MAX_MOVE_OPS_PER_LOOP_ITER memory-to-memory + moves, so allow individual copies of fewer elements. + + When cpymemsi is not available, use a value approximating +@@ -1087,9 +1087,7 @@ typedef struct { + value of LARCH_CALL_RATIO to take that into account. */ + + #define MOVE_RATIO(speed) \ +- (HAVE_cpymemsi \ +- ? LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER / UNITS_PER_WORD \ +- : CLEAR_RATIO (speed) / 2) ++ (HAVE_cpymemsi ? LARCH_MAX_MOVE_OPS_PER_LOOP_ITER : CLEAR_RATIO (speed) / 2) + + /* For CLEAR_RATIO, when optimizing for size, give a better estimate + of the length of a memset call, but use the default otherwise. */ +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index b2f7c7f78..b23248c33 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -2488,7 +2488,8 @@ + "" + { + if (TARGET_DO_OPTIMIZE_BLOCK_MOVE_P +- && loongarch_expand_block_move (operands0, operands1, operands2)) ++ && loongarch_expand_block_move (operands0, operands1, ++ operands2, operands3)) + DONE; + else + FAIL; +diff --git a/gcc/testsuite/gcc.target/loongarch/pr109465-1.c b/gcc/testsuite/gcc.target/loongarch/pr109465-1.c +new file mode 100644 +index 000000000..4cd35d139 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/pr109465-1.c +@@ -0,0 +1,9 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d -mno-strict-align" } */ ++/* { dg-final { scan-assembler-times "st\\.d|stptr\\.d" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.w|stptr\\.w" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.h" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.b" 1 } } */ ++ ++extern char a, b; ++void test() { __builtin_memcpy(a, b, 15); } +diff --git a/gcc/testsuite/gcc.target/loongarch/pr109465-2.c b/gcc/testsuite/gcc.target/loongarch/pr109465-2.c +new file mode 100644 +index 000000000..703eb951c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/pr109465-2.c +@@ -0,0 +1,9 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d -mstrict-align" } */ ++/* { dg-final { scan-assembler-times "st\\.d|stptr\\.d" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.w|stptr\\.w" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.h" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.b" 1 } } */ ++ ++extern long a, b; ++void test() { __builtin_memcpy(a, b, 15); } +diff --git a/gcc/testsuite/gcc.target/loongarch/pr109465-3.c b/gcc/testsuite/gcc.target/loongarch/pr109465-3.c +new file mode 100644 +index 000000000..d6a80659b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/pr109465-3.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d -mstrict-align" } */ ++ ++/* Three loop iterations each contains 4 st.b, and 3 st.b after the loop */ ++/* { dg-final { scan-assembler-times "st\\.b" 7 } } */ ++ ++/* { dg-final { scan-assembler-not "st\\.h" } } */ ++/* { dg-final { scan-assembler-not "st\\.w|stptr\\.w" } } */ ++/* { dg-final { scan-assembler-not "st\\.d|stptr\\.d" } } */ ++ ++extern char a, b; ++void test() { __builtin_memcpy(a, b, 15); } +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Libitm-add-LoongArch-support.patch
Added
@@ -0,0 +1,291 @@ +From 7f9f1dd3c87cffeab58150997e22e8fff707646b Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Mon, 26 Sep 2022 09:42:51 +0800 +Subject: PATCH 019/124 LoongArch: Libitm add LoongArch support. + +Co-Authored-By: Yang Yujie <yangyujie@loongson.cn> + +libitm/ChangeLog: + + * configure.tgt: Add loongarch support. + * config/loongarch/asm.h: New file. + * config/loongarch/sjlj.S: New file. + * config/loongarch/target.h: New file. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + libitm/config/loongarch/asm.h | 54 +++++++++++++ + libitm/config/loongarch/sjlj.S | 127 +++++++++++++++++++++++++++++++ + libitm/config/loongarch/target.h | 50 ++++++++++++ + libitm/configure.tgt | 2 + + 4 files changed, 233 insertions(+) + create mode 100644 libitm/config/loongarch/asm.h + create mode 100644 libitm/config/loongarch/sjlj.S + create mode 100644 libitm/config/loongarch/target.h + +diff --git a/libitm/config/loongarch/asm.h b/libitm/config/loongarch/asm.h +new file mode 100644 +index 000000000..a8e3304bb +--- /dev/null ++++ b/libitm/config/loongarch/asm.h +@@ -0,0 +1,54 @@ ++/* Copyright (C) 2022 Free Software Foundation, Inc. ++ Contributed by Loongson Co. Ltd. ++ ++ This file is part of the GNU Transactional Memory Library (libitm). ++ ++ Libitm is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3 of the License, or ++ (at your option) any later version. ++ ++ Libitm is distributed in the hope that it will be useful, but WITHOUT ANY ++ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS ++ FOR A PARTICULAR PURPOSE. See the GNU General Public License for ++ more details. ++ ++ Under Section 7 of GPL version 3, you are granted additional ++ permissions described in the GCC Runtime Library Exception, version ++ 3.1, as published by the Free Software Foundation. ++ ++ You should have received a copy of the GNU General Public License and ++ a copy of the GCC Runtime Library Exception along with this program; ++ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see ++ <http://www.gnu.org/licenses/>. */ ++ ++#ifndef _LA_ASM_H ++#define _LA_ASM_H ++ ++#if defined(__loongarch_lp64) ++# define GPR_L ld.d ++# define GPR_S st.d ++# define SZ_GPR 8 ++# define ADDSP(si) addi.d $sp, $sp, si ++#elif defined(__loongarch64_ilp32) ++# define GPR_L ld.w ++# define GPR_S st.w ++# define SZ_GPR 4 ++# define ADDSP(si) addi.w $sp, $sp, si ++#else ++# error Unsupported GPR size (must be 64-bit or 32-bit). ++#endif ++ ++#if defined(__loongarch_double_float) ++# define FPR_L fld.d ++# define FPR_S fst.d ++# define SZ_FPR 8 ++#elif defined(__loongarch_single_float) ++# define FPR_L fld.s ++# define FPR_S fst.s ++# define SZ_FPR 4 ++#else ++# define SZ_FPR 0 ++#endif ++ ++#endif /* _LA_ASM_H */ +diff --git a/libitm/config/loongarch/sjlj.S b/libitm/config/loongarch/sjlj.S +new file mode 100644 +index 000000000..a5f9fadde +--- /dev/null ++++ b/libitm/config/loongarch/sjlj.S +@@ -0,0 +1,127 @@ ++/* Copyright (C) 2022 Free Software Foundation, Inc. ++ Contributed by Loongson Co. Ltd. ++ ++ This file is part of the GNU Transactional Memory Library (libitm). ++ ++ Libitm is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3 of the License, or ++ (at your option) any later version. ++ ++ Libitm is distributed in the hope that it will be useful, but WITHOUT ANY ++ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS ++ FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. ++ ++ Under Section 7 of GPL version 3, you are granted additional ++ permissions described in the GCC Runtime Library Exception, version ++ 3.1, as published by the Free Software Foundation. ++ ++ You should have received a copy of the GNU General Public License and ++ a copy of the GCC Runtime Library Exception along with this program; ++ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see ++ <http://www.gnu.org/licenses/>. */ ++ ++#include "asmcfi.h" ++#include "asm.h" ++ ++ .text ++ .align 2 ++ .global _ITM_beginTransaction ++ .type _ITM_beginTransaction, @function ++ ++_ITM_beginTransaction: ++ cfi_startproc ++ move $r5, $sp ++ ADDSP(-(12*SZ_GPR+8*SZ_FPR)) ++ cfi_adjust_cfa_offset(12*SZ_GPR+8*SZ_FPR) ++ ++ /* Frame Pointer */ ++ GPR_S $fp, $sp, 0*SZ_GPR ++ cfi_rel_offset(22, 0) ++ ++ /* Return Address */ ++ GPR_S $r1, $sp, 1*SZ_GPR ++ cfi_rel_offset(1, SZ_GPR) ++ ++ /* Caller's $sp */ ++ GPR_S $r5, $sp, 2*SZ_GPR ++ ++ /* Callee-saved scratch GPRs (r23-r31) */ ++ GPR_S $s0, $sp, 3*SZ_GPR ++ GPR_S $s1, $sp, 4*SZ_GPR ++ GPR_S $s2, $sp, 5*SZ_GPR ++ GPR_S $s3, $sp, 6*SZ_GPR ++ GPR_S $s4, $sp, 7*SZ_GPR ++ GPR_S $s5, $sp, 8*SZ_GPR ++ GPR_S $s6, $sp, 9*SZ_GPR ++ GPR_S $s7, $sp, 10*SZ_GPR ++ GPR_S $s8, $sp, 11*SZ_GPR ++ ++#if !defined(__loongarch_soft_float) ++ /* Callee-saved scratch FPRs (f24-f31) */ ++ FPR_S $f24, $sp, 12*SZ_GPR + 0*SZ_FPR ++ FPR_S $f25, $sp, 12*SZ_GPR + 1*SZ_FPR ++ FPR_S $f26, $sp, 12*SZ_GPR + 2*SZ_FPR ++ FPR_S $f27, $sp, 12*SZ_GPR + 3*SZ_FPR ++ FPR_S $f28, $sp, 12*SZ_GPR + 4*SZ_FPR ++ FPR_S $f29, $sp, 12*SZ_GPR + 5*SZ_FPR ++ FPR_S $f30, $sp, 12*SZ_GPR + 6*SZ_FPR ++ FPR_S $f31, $sp, 12*SZ_GPR + 7*SZ_FPR ++#endif ++ move $fp, $sp ++ ++ /* Invoke GTM_begin_transaction with the struct we've just built. */ ++ move $r5, $sp ++ bl %plt(GTM_begin_transaction) ++ ++ /* Return. (no call-saved scratch reg needs to be restored here) */ ++ GPR_L $fp, $sp, 0*SZ_GPR ++ cfi_restore(22) ++ GPR_L $r1, $sp, 1*SZ_GPR ++ cfi_restore(1) ++ ++ ADDSP(12*SZ_GPR+8*SZ_FPR) ++ cfi_adjust_cfa_offset(-(12*SZ_GPR+8*SZ_FPR)) ++ ++ jr $r1 ++ cfi_endproc ++ .size _ITM_beginTransaction, . - _ITM_beginTransaction ++ ++ .align 2 ++ .global GTM_longjmp ++ .hidden GTM_longjmp ++ .type GTM_longjmp, @function ++ ++GTM_longjmp: ++ cfi_startproc ++ GPR_L $s0, $r5, 3*SZ_GPR ++ GPR_L $s1, $r5, 4*SZ_GPR ++ GPR_L $s2, $r5, 5*SZ_GPR ++ GPR_L $s3, $r5, 6*SZ_GPR ++ GPR_L $s4, $r5, 7*SZ_GPR ++ GPR_L $s5, $r5, 8*SZ_GPR ++ GPR_L $s6, $r5, 9*SZ_GPR ++ GPR_L $s7, $r5, 10*SZ_GPR ++ GPR_L $s8, $r5, 11*SZ_GPR ++ ++ FPR_L $f24, $r5, 12*SZ_GPR + 0*SZ_FPR ++ FPR_L $f25, $r5, 12*SZ_GPR + 1*SZ_FPR ++ FPR_L $f26, $r5, 12*SZ_GPR + 2*SZ_FPR ++ FPR_L $f27, $r5, 12*SZ_GPR + 3*SZ_FPR ++ FPR_L $f28, $r5, 12*SZ_GPR + 4*SZ_FPR ++ FPR_L $f29, $r5, 12*SZ_GPR + 5*SZ_FPR ++ FPR_L $f30, $r5, 12*SZ_GPR + 6*SZ_FPR ++ FPR_L $f31, $r5, 12*SZ_GPR + 7*SZ_FPR ++ ++ GPR_L $r7, $r5, 2*SZ_GPR ++ GPR_L $fp, $r5, 0*SZ_GPR ++ GPR_L $r1, $r5, 1*SZ_GPR ++ cfi_def_cfa(5, 0) ++ move $sp, $r7 ++ jr $r1 ++ cfi_endproc ++ .size GTM_longjmp, . - GTM_longjmp ++ ++#ifdef __linux__ ++.section .note.GNU-stack, "", @progbits ++#endif +diff --git a/libitm/config/loongarch/target.h b/libitm/config/loongarch/target.h +new file mode 100644 +index 000000000..0c5cf3ada +--- /dev/null ++++ b/libitm/config/loongarch/target.h +@@ -0,0 +1,50 @@ ++/* Copyright (C) 2022 Free Software Foundation, Inc. ++ Contributed by Loongson Co. Ltd. ++ ++ This file is part of the GNU Transactional Memory Library (libitm). ++ ++ Libitm is free software; you can redistribute it and/or modify it ++ under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3 of the License, or ++ (at your option) any later version. ++ ++ Libitm is distributed in the hope that it will be useful, but WITHOUT ANY ++ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS ++ FOR A PARTICULAR PURPOSE. See the GNU General Public License for ++ more details. ++ ++ Under Section 7 of GPL version 3, you are granted additional ++ permissions described in the GCC Runtime Library Exception, version ++ 3.1, as published by the Free Software Foundation. ++ ++ You should have received a copy of the GNU General Public License and ++ a copy of the GCC Runtime Library Exception along with this program; ++ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see ++ <http://www.gnu.org/licenses/>. */ ++ ++namespace GTM HIDDEN { ++ ++typedef struct gtm_jmpbuf ++ { ++ long int fp; /* Frame Pointer: r22 */ ++ long int pc; /* Return Address: r1 */ ++ void *cfa; /* CFA: r3 */ ++ long int gpr9; /* Callee-saved scratch GPRs: r23(s0)-r31(s8) */ ++ ++ /* Callee-saved scratch FPRs: f24-f31 */ ++#if defined(__loongarch_double_float) ++ double fpr8; ++#elif defined(__loongarch_single_float) ++ float fpr8; ++#endif ++ } gtm_jmpbuf; ++ ++#define HW_CACHELINE_SIZE 128 ++ ++static inline void ++cpu_relax (void) ++{ ++ __asm__ volatile ("" : : : "memory"); ++} ++ ++} // namespace GTM +diff --git a/libitm/configure.tgt b/libitm/configure.tgt +index 06e90973e..4c0e78cff 100644 +--- a/libitm/configure.tgt ++++ b/libitm/configure.tgt +@@ -80,6 +80,8 @@ EOF + ARCH=x86 + ;; + ++ loongarch*) ARCH=loongarch ;; ++ + sh*) ARCH=sh ;; + + sparc) +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Modify-the-output-message-string-of-the-wa.patch
Added
@@ -0,0 +1,37 @@ +From 83d6cfbbdc41766af9d7941d00204cc0f26ff40c Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Tue, 26 Jul 2022 21:03:52 +0800 +Subject: PATCH 005/124 LoongArch: Modify the output message string of the + warning. + +Fix bug for "error: spurious trailing punctuation sequence '.' in format -Werror=format-diag". + +gcc/ChangeLog: + + * config/loongarch/loongarch-opts.cc: Modify the output message string + of the warning. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-opts.cc | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/gcc/config/loongarch/loongarch-opts.cc b/gcc/config/loongarch/loongarch-opts.cc +index fc477bfd4..3f70943de 100644 +--- a/gcc/config/loongarch/loongarch-opts.cc ++++ b/gcc/config/loongarch/loongarch-opts.cc +@@ -378,8 +378,8 @@ fallback: + t.cmodel = constrained.cmodel ? opt_cmodel : CMODEL_NORMAL; + if (t.cmodel != CMODEL_NORMAL) + { +- warning (0, "%qs is not supported, now cmodel is set to 'normal'.", +- loongarch_cmodel_stringst.cmodel); ++ warning (0, "%qs is not supported, now cmodel is set to %qs", ++ loongarch_cmodel_stringst.cmodel, "normal"); + t.cmodel = CMODEL_NORMAL; + } + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Optimize-additions-with-immediates.patch
Added
@@ -0,0 +1,445 @@ +From a31baa1e437fa4acedfaf03db91c1d6e5ce78013 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Sun, 2 Apr 2023 21:37:49 +0800 +Subject: PATCH 041/124 LoongArch: Optimize additions with immediates + +1. Use addu16i.d for TARGET_64BIT and suitable immediates. +2. Split one addition with immediate into two addu16i.d or addi.{d/w} + instructions if possible. This can avoid using a temp register w/o + increase the count of instructions. + +Inspired by https://reviews.llvm.org/D143710 and +https://reviews.llvm.org/D147222. + +Bootstrapped and regtested on loongarch64-linux-gnu. Ok for GCC 14? + +gcc/ChangeLog: + + * config/loongarch/loongarch-protos.h + (loongarch_addu16i_imm12_operand_p): New function prototype. + (loongarch_split_plus_constant): Likewise. + * config/loongarch/loongarch.cc + (loongarch_addu16i_imm12_operand_p): New function. + (loongarch_split_plus_constant): Likewise. + * config/loongarch/loongarch.h (ADDU16I_OPERAND): New macro. + (DUAL_IMM12_OPERAND): Likewise. + (DUAL_ADDU16I_OPERAND): Likewise. + * config/loongarch/constraints.md (La, Lb, Lc, Ld, Le): New + constraint. + * config/loongarch/predicates.md (const_dual_imm12_operand): New + predicate. + (const_addu16i_operand): Likewise. + (const_addu16i_imm12_di_operand): Likewise. + (const_addu16i_imm12_si_operand): Likewise. + (plus_di_operand): Likewise. + (plus_si_operand): Likewise. + (plus_si_extend_operand): Likewise. + * config/loongarch/loongarch.md (add<mode>3): Convert to + define_insn_and_split. Use plus_<mode>_operand predicate + instead of arith_operand. Add alternatives for La, Lb, Lc, Ld, + and Le constraints. + (*addsi3_extended): Convert to define_insn_and_split. Use + plus_si_extend_operand instead of arith_operand. Add + alternatives for La and Le alternatives. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/add-const.c: New test. + * gcc.target/loongarch/stack-check-cfa-1.c: Adjust for stack + frame size change. + * gcc.target/loongarch/stack-check-cfa-2.c: Likewise. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/constraints.md | 46 ++++++++++++- + gcc/config/loongarch/loongarch-protos.h | 2 + + gcc/config/loongarch/loongarch.cc | 44 +++++++++++++ + gcc/config/loongarch/loongarch.h | 19 ++++++ + gcc/config/loongarch/loongarch.md | 66 +++++++++++++++---- + gcc/config/loongarch/predicates.md | 36 ++++++++++ + .../gcc.target/loongarch/add-const.c | 45 +++++++++++++ + .../gcc.target/loongarch/stack-check-cfa-1.c | 2 +- + .../gcc.target/loongarch/stack-check-cfa-2.c | 2 +- + 9 files changed, 246 insertions(+), 16 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/add-const.c + +diff --git a/gcc/config/loongarch/constraints.md b/gcc/config/loongarch/constraints.md +index 46f7f63ae..25f3cda35 100644 +--- a/gcc/config/loongarch/constraints.md ++++ b/gcc/config/loongarch/constraints.md +@@ -60,7 +60,22 @@ + ;; "I" "A signed 12-bit constant (for arithmetic instructions)." + ;; "J" "Integer zero." + ;; "K" "An unsigned 12-bit constant (for logic instructions)." +-;; "L" <-----unused ++;; "L" - ++;; "La" ++;; "A signed constant in -4096, 2048) or (2047, 4094." ++;; "Lb" ++;; "A signed 32-bit constant and low 16-bit is zero, which can be ++;; added onto a register with addu16i.d. It matches nothing if ++;; the addu16i.d instruction is not available." ++;; "Lc" ++;; "A signed 64-bit constant can be expressed as Lb + I, but not a ++;; single Lb or I." ++;; "Ld" ++;; "A signed 64-bit constant can be expressed as Lb + Lb, but not a ++;; single Lb." ++;; "Le" ++;; "A signed 32-bit constant can be expressed as Lb + I, but not a ++;; single Lb or I." + ;; "M" <-----unused + ;; "N" <-----unused + ;; "O" <-----unused +@@ -170,6 +185,35 @@ + (and (match_code "const_int") + (match_test "IMM12_OPERAND_UNSIGNED (ival)"))) + ++(define_constraint "La" ++ "A signed constant in -4096, 2048) or (2047, 4094." ++ (and (match_code "const_int") ++ (match_test "DUAL_IMM12_OPERAND (ival)"))) ++ ++(define_constraint "Lb" ++ "A signed 32-bit constant and low 16-bit is zero, which can be added ++ onto a register with addu16i.d." ++ (and (match_code "const_int") ++ (match_test "ADDU16I_OPERAND (ival)"))) ++ ++(define_constraint "Lc" ++ "A signed 64-bit constant can be expressed as Lb + I, but not a single Lb ++ or I." ++ (and (match_code "const_int") ++ (match_test "loongarch_addu16i_imm12_operand_p (ival, DImode)"))) ++ ++(define_constraint "Ld" ++ "A signed 64-bit constant can be expressed as Lb + Lb, but not a single ++ Lb." ++ (and (match_code "const_int") ++ (match_test "DUAL_ADDU16I_OPERAND (ival)"))) ++ ++(define_constraint "Le" ++ "A signed 32-bit constant can be expressed as Lb + I, but not a single Lb ++ or I." ++ (and (match_code "const_int") ++ (match_test "loongarch_addu16i_imm12_operand_p (ival, SImode)"))) ++ + (define_constraint "Yd" + "@internal + A constant @code{move_operand} that can be safely loaded using +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 77b221724..0a9b47722 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -83,6 +83,8 @@ extern rtx loongarch_legitimize_call_address (rtx); + extern rtx loongarch_subword (rtx, bool); + extern bool loongarch_split_move_p (rtx, rtx); + extern void loongarch_split_move (rtx, rtx, rtx); ++extern bool loongarch_addu16i_imm12_operand_p (HOST_WIDE_INT, machine_mode); ++extern void loongarch_split_plus_constant (rtx *, machine_mode); + extern const char *loongarch_output_move (rtx, rtx); + extern bool loongarch_cfun_has_cprestore_slot_p (void); + #ifdef RTX_CODE +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 1a4686f03..233dddbac 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -3753,6 +3753,50 @@ loongarch_split_move (rtx dest, rtx src, rtx insn_) + } + } + ++/* Check if adding an integer constant value for a specific mode can be ++ performed with an addu16i.d instruction and an addi.{w/d} ++ instruction. */ ++ ++bool ++loongarch_addu16i_imm12_operand_p (HOST_WIDE_INT value, machine_mode mode) ++{ ++ /* Not necessary, but avoid unnecessary calculation if !TARGET_64BIT. */ ++ if (!TARGET_64BIT) ++ return false; ++ ++ if ((value & 0xffff) == 0) ++ return false; ++ ++ if (IMM12_OPERAND (value)) ++ return false; ++ ++ value = (value & ~HWIT_UC_0xFFF) + ((value & 0x800) << 1); ++ return ADDU16I_OPERAND (trunc_int_for_mode (value, mode)); ++} ++ ++/* Split one integer constant op0 into two (op1 and op2) for constant ++ plus operation in a specific mode. The splitted constants can be added ++ onto a register with a single instruction (addi.{d/w} or addu16i.d). */ ++ ++void ++loongarch_split_plus_constant (rtx *op, machine_mode mode) ++{ ++ HOST_WIDE_INT v = INTVAL (op0), a; ++ ++ if (DUAL_IMM12_OPERAND (v)) ++ a = (v > 0 ? 2047 : -2048); ++ else if (loongarch_addu16i_imm12_operand_p (v, mode)) ++ a = (v & ~HWIT_UC_0xFFF) + ((v & 0x800) << 1); ++ else if (mode == DImode && DUAL_ADDU16I_OPERAND (v)) ++ a = (v > 0 ? 0x7fff : -0x8000) << 16; ++ else ++ gcc_unreachable (); ++ ++ op1 = gen_int_mode (a, mode); ++ v = v - (unsigned HOST_WIDE_INT) a; ++ op2 = gen_int_mode (v, mode); ++} ++ + /* Return true if a move from SRC to DEST in INSN should be split. */ + + static bool +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index c6e37b1b4..9d3cd9ca0 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -612,6 +612,25 @@ enum reg_class + + #define CONST_LOW_PART(VALUE) ((VALUE) - CONST_HIGH_PART (VALUE)) + ++/* True if VALUE can be added onto a register with one addu16i.d ++ instruction. */ ++ ++#define ADDU16I_OPERAND(VALUE) \ ++ (TARGET_64BIT && (((VALUE) & 0xffff) == 0 \ ++ && IMM16_OPERAND ((HOST_WIDE_INT) (VALUE) / 65536))) ++ ++/* True if VALUE can be added onto a register with two addi.{d/w} ++ instructions, but not one addi.{d/w} instruction. */ ++#define DUAL_IMM12_OPERAND(VALUE) \ ++ (IN_RANGE ((VALUE), -4096, 4094) && !IMM12_OPERAND (VALUE)) ++ ++/* True if VALUE can be added onto a register with two addu16i.d ++ instruction, but not one addu16i.d instruction. */ ++#define DUAL_ADDU16I_OPERAND(VALUE) \ ++ (TARGET_64BIT && (((VALUE) & 0xffff) == 0 \ ++ && !ADDU16I_OPERAND (VALUE) \ ++ && IN_RANGE ((VALUE) / 65536, -0x10000, 0xfffe))) ++ + #define IMM12_INT(X) IMM12_OPERAND (INTVAL (X)) + #define IMM12_INT_UNSIGNED(X) IMM12_OPERAND_UNSIGNED (INTVAL (X)) + #define LU12I_INT(X) LU12I_OPERAND (INTVAL (X)) +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 833b94753..b2f7c7f78 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -598,24 +598,64 @@ + (set_attr "type" "fadd") + (set_attr "mode" "<UNITMODE>")) + +-(define_insn "add<mode>3" +- (set (match_operand:GPR 0 "register_operand" "=r,r") +- (plus:GPR (match_operand:GPR 1 "register_operand" "r,r") +- (match_operand:GPR 2 "arith_operand" "r,I"))) ++(define_insn_and_split "add<mode>3" ++ (set (match_operand:GPR 0 "register_operand" "=r,r,r,r,r,r,r") ++ (plus:GPR (match_operand:GPR 1 "register_operand" "r,r,r,r,r,r,r") ++ (match_operand:GPR 2 "plus_<mode>_operand" ++ "r,I,La,Lb,Lc,Ld,Le"))) + "" +- "add%i2.<d>\t%0,%1,%2"; ++ "@ ++ add.<d>\t%0,%1,%2 ++ addi.<d>\t%0,%1,%2 ++ # ++ * operands2 = GEN_INT (INTVAL (operands2) / 65536); \ ++ return \"addu16i.d\t%0,%1,%2\"; ++ # ++ # ++ #" ++ "CONST_INT_P (operands2) && !IMM12_INT (operands2) \ ++ && !ADDU16I_OPERAND (INTVAL (operands2))" ++ (set (match_dup 0) (plus:GPR (match_dup 1) (match_dup 3))) ++ (set (match_dup 0) (plus:GPR (match_dup 0) (match_dup 4))) ++ { ++ loongarch_split_plus_constant (&operands2, <MODE>mode); ++ } + (set_attr "alu_type" "add") +- (set_attr "mode" "<MODE>")) +- +-(define_insn "*addsi3_extended" +- (set (match_operand:DI 0 "register_operand" "=r,r") ++ (set_attr "mode" "<MODE>") ++ (set_attr "insn_count" "1,1,2,1,2,2,2") ++ (set (attr "enabled") ++ (cond ++ (match_test "<MODE>mode != DImode && which_alternative == 4") ++ (const_string "no") ++ (match_test "<MODE>mode != DImode && which_alternative == 5") ++ (const_string "no") ++ (match_test "<MODE>mode != SImode && which_alternative == 6") ++ (const_string "no") ++ (const_string "yes")))) ++ ++(define_insn_and_split "*addsi3_extended" ++ (set (match_operand:DI 0 "register_operand" "=r,r,r,r") + (sign_extend:DI +- (plus:SI (match_operand:SI 1 "register_operand" "r,r") +- (match_operand:SI 2 "arith_operand" "r,I")))) ++ (plus:SI (match_operand:SI 1 "register_operand" "r,r,r,r") ++ (match_operand:SI 2 "plus_si_extend_operand" ++ "r,I,La,Le")))) + "TARGET_64BIT" +- "add%i2.w\t%0,%1,%2" ++ "@ ++ add.w\t%0,%1,%2 ++ addi.w\t%0,%1,%2 ++ # ++ #" ++ "CONST_INT_P (operands2) && !IMM12_INT (operands2)" ++ (set (subreg:SI (match_dup 0) 0) (plus:SI (match_dup 1) (match_dup 3))) ++ (set (match_dup 0) ++ (sign_extend:DI (plus:SI (subreg:SI (match_dup 0) 0) ++ (match_dup 4)))) ++ { ++ loongarch_split_plus_constant (&operands2, SImode); ++ } + (set_attr "alu_type" "add") +- (set_attr "mode" "SI")) ++ (set_attr "mode" "SI") ++ (set_attr "insn_count" "1,1,2,2")) + +  + ;; +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index 3c32b2987..4966d5569 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -39,14 +39,50 @@ + (and (match_code "const_int") + (match_test "IMM12_OPERAND (INTVAL (op))"))) + ++(define_predicate "const_dual_imm12_operand" ++ (and (match_code "const_int") ++ (match_test "DUAL_IMM12_OPERAND (INTVAL (op))"))) ++ + (define_predicate "const_imm16_operand" + (and (match_code "const_int") + (match_test "IMM16_OPERAND (INTVAL (op))"))) + ++(define_predicate "const_addu16i_operand" ++ (and (match_code "const_int") ++ (match_test "ADDU16I_OPERAND (INTVAL (op))"))) ++ ++(define_predicate "const_addu16i_imm12_di_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_addu16i_imm12_operand_p (INTVAL (op), DImode)"))) ++ ++(define_predicate "const_addu16i_imm12_si_operand" ++ (and (match_code "const_int") ++ (match_test "loongarch_addu16i_imm12_operand_p (INTVAL (op), SImode)"))) ++ ++(define_predicate "const_dual_addu16i_operand" ++ (and (match_code "const_int") ++ (match_test "DUAL_ADDU16I_OPERAND (INTVAL (op))"))) ++ + (define_predicate "arith_operand" + (ior (match_operand 0 "const_arith_operand") + (match_operand 0 "register_operand"))) + ++(define_predicate "plus_di_operand" ++ (ior (match_operand 0 "arith_operand") ++ (match_operand 0 "const_dual_imm12_operand") ++ (match_operand 0 "const_addu16i_operand") ++ (match_operand 0 "const_addu16i_imm12_di_operand") ++ (match_operand 0 "const_dual_addu16i_operand"))) ++ ++(define_predicate "plus_si_extend_operand" ++ (ior (match_operand 0 "arith_operand") ++ (match_operand 0 "const_dual_imm12_operand") ++ (match_operand 0 "const_addu16i_imm12_si_operand"))) ++ ++(define_predicate "plus_si_operand" ++ (ior (match_operand 0 "plus_si_extend_operand") ++ (match_operand 0 "const_addu16i_operand"))) ++ + (define_predicate "const_immalsl_operand" + (and (match_code "const_int") + (match_test "IN_RANGE (INTVAL (op), 1, 4)"))) +diff --git a/gcc/testsuite/gcc.target/loongarch/add-const.c b/gcc/testsuite/gcc.target/loongarch/add-const.c +new file mode 100644 +index 000000000..7b6a7cb92 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/add-const.c +@@ -0,0 +1,45 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O -mabi=lp64d" } */ ++ ++/* None of these functions should load the const operand into a temp ++ register. */ ++ ++/* { dg-final { scan-assembler-not "add\\.dw" } } */ ++ ++unsigned long f01 (unsigned long x) { return x + 1; } ++unsigned long f02 (unsigned long x) { return x - 1; } ++unsigned long f03 (unsigned long x) { return x + 2047; } ++unsigned long f04 (unsigned long x) { return x + 4094; } ++unsigned long f05 (unsigned long x) { return x - 2048; } ++unsigned long f06 (unsigned long x) { return x - 4096; } ++unsigned long f07 (unsigned long x) { return x + 0x7fff0000; } ++unsigned long f08 (unsigned long x) { return x - 0x80000000l; } ++unsigned long f09 (unsigned long x) { return x + 0x7fff0000l * 2; } ++unsigned long f10 (unsigned long x) { return x - 0x80000000l * 2; } ++unsigned long f11 (unsigned long x) { return x + 0x7fff0000 + 0x1; } ++unsigned long f12 (unsigned long x) { return x + 0x7fff0000 - 0x1; } ++unsigned long f13 (unsigned long x) { return x + 0x7fff0000 + 0x7ff; } ++unsigned long f14 (unsigned long x) { return x + 0x7fff0000 - 0x800; } ++unsigned long f15 (unsigned long x) { return x - 0x80000000l - 1; } ++unsigned long f16 (unsigned long x) { return x - 0x80000000l + 1; } ++unsigned long f17 (unsigned long x) { return x - 0x80000000l - 0x800; } ++unsigned long f18 (unsigned long x) { return x - 0x80000000l + 0x7ff; } ++ ++unsigned int g01 (unsigned int x) { return x + 1; } ++unsigned int g02 (unsigned int x) { return x - 1; } ++unsigned int g03 (unsigned int x) { return x + 2047; } ++unsigned int g04 (unsigned int x) { return x + 4094; } ++unsigned int g05 (unsigned int x) { return x - 2048; } ++unsigned int g06 (unsigned int x) { return x - 4096; } ++unsigned int g07 (unsigned int x) { return x + 0x7fff0000; } ++unsigned int g08 (unsigned int x) { return x - 0x80000000l; } ++unsigned int g09 (unsigned int x) { return x + 0x7fff0000l * 2; } ++unsigned int g10 (unsigned int x) { return x - 0x80000000l * 2; } ++unsigned int g11 (unsigned int x) { return x + 0x7fff0000 + 0x1; } ++unsigned int g12 (unsigned int x) { return x + 0x7fff0000 - 0x1; } ++unsigned int g13 (unsigned int x) { return x + 0x7fff0000 + 0x7ff; } ++unsigned int g14 (unsigned int x) { return x + 0x7fff0000 - 0x800; } ++unsigned int g15 (unsigned int x) { return x - 0x80000000l - 1; } ++unsigned int g16 (unsigned int x) { return x - 0x80000000l + 1; } ++unsigned int g17 (unsigned int x) { return x - 0x80000000l - 0x800; } ++unsigned int g18 (unsigned int x) { return x - 0x80000000l + 0x7ff; } +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c +index 3533fe7b6..cd72154f4 100644 +--- a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c +@@ -6,7 +6,7 @@ + #define SIZE 128*1024 + #include "stack-check-prologue.h" + +-/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 131088} 1 } } */ ++/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 131072} 1 } } */ + /* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 0} 1 } } */ + + /* Checks that the CFA notes are correct for every sp adjustment. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c +index e5e711105..3e5ca05b2 100644 +--- a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c +@@ -6,7 +6,7 @@ + #define SIZE 1280*1024 + 512 + #include "stack-check-prologue.h" + +-/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 1311248} 1 } } */ ++/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 1311232} 1 } } */ + /* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 0} 1 } } */ + + /* Checks that the CFA notes are correct for every sp adjustment. */ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Optimize-immediate-load.patch
Added
@@ -0,0 +1,338 @@ +From b533b615ae47b97d51eeb83e1a63f7c72407430f Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 17 Nov 2022 17:08:36 +0800 +Subject: PATCH 032/124 LoongArch: Optimize immediate load. + +The immediate number is split in the Split pass, not in the expand pass. + +Because loop2_invariant pass will extract the instructions that do not change +in the loop out of the loop, some instructions will not meet the extraction +conditions if the machine performs immediate decomposition while expand pass, +so the immediate decomposition will be transferred to the split process. + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (enum loongarch_load_imm_method): + Remove the member METHOD_INSV that is not currently used. + (struct loongarch_integer_op): Define a new member curr_value, + that records the value of the number stored in the destination + register immediately after the current instruction has run. + (loongarch_build_integer): Assign a value to the curr_value member variable. + (loongarch_move_integer): Adds information for the immediate load instruction. + * config/loongarch/loongarch.md (*movdi_32bit): Redefine as define_insn_and_split. + (*movdi_64bit): Likewise. + (*movsi_internal): Likewise. + (*movhi_internal): Likewise. + * config/loongarch/predicates.md: Return true as long as it is CONST_INT, ensure + that the immediate number is not optimized by decomposition during expand + optimization loop. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/imm-load.c: New test. + * gcc.target/loongarch/imm-load1.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 62 ++++++++++--------- + gcc/config/loongarch/loongarch.md | 44 +++++++++++-- + gcc/config/loongarch/predicates.md | 2 +- + gcc/testsuite/gcc.target/loongarch/imm-load.c | 10 +++ + .../gcc.target/loongarch/imm-load1.c | 26 ++++++++ + 5 files changed, 110 insertions(+), 34 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/imm-load.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/imm-load1.c + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 622c9435b..f45a49f90 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -139,22 +139,21 @@ struct loongarch_address_info + + METHOD_LU52I: + Load 52-63 bit of the immediate number. +- +- METHOD_INSV: +- immediate like 0xfff00000fffffxxx +- */ ++*/ + enum loongarch_load_imm_method + { + METHOD_NORMAL, + METHOD_LU32I, +- METHOD_LU52I, +- METHOD_INSV ++ METHOD_LU52I + }; + + struct loongarch_integer_op + { + enum rtx_code code; + HOST_WIDE_INT value; ++ /* Represent the result of the immediate count of the load instruction at ++ each step. */ ++ HOST_WIDE_INT curr_value; + enum loongarch_load_imm_method method; + }; + +@@ -1474,24 +1473,27 @@ loongarch_build_integer (struct loongarch_integer_op *codes, + { + /* The value of the lower 32 bit be loaded with one instruction. + lu12i.w. */ +- codes0.code = UNKNOWN; +- codes0.method = METHOD_NORMAL; +- codes0.value = low_part; ++ codescost.code = UNKNOWN; ++ codescost.method = METHOD_NORMAL; ++ codescost.value = low_part; ++ codescost.curr_value = low_part; + cost++; + } + else + { + /* lu12i.w + ior. */ +- codes0.code = UNKNOWN; +- codes0.method = METHOD_NORMAL; +- codes0.value = low_part & ~(IMM_REACH - 1); ++ codescost.code = UNKNOWN; ++ codescost.method = METHOD_NORMAL; ++ codescost.value = low_part & ~(IMM_REACH - 1); ++ codescost.curr_value = codescost.value; + cost++; + HOST_WIDE_INT iorv = low_part & (IMM_REACH - 1); + if (iorv != 0) + { +- codes1.code = IOR; +- codes1.method = METHOD_NORMAL; +- codes1.value = iorv; ++ codescost.code = IOR; ++ codescost.method = METHOD_NORMAL; ++ codescost.value = iorv; ++ codescost.curr_value = low_part; + cost++; + } + } +@@ -1514,11 +1516,14 @@ loongarch_build_integer (struct loongarch_integer_op *codes, + { + codescost.method = METHOD_LU52I; + codescost.value = value & LU52I_B; ++ codescost.curr_value = value; + return cost + 1; + } + + codescost.method = METHOD_LU32I; + codescost.value = (value & LU32I_B) | (sign51 ? LU52I_B : 0); ++ codescost.curr_value = (value & 0xfffffffffffff) ++ | (sign51 ? LU52I_B : 0); + cost++; + + /* Determine whether the 52-61 bits are sign-extended from the low order, +@@ -1527,6 +1532,7 @@ loongarch_build_integer (struct loongarch_integer_op *codes, + { + codescost.method = METHOD_LU52I; + codescost.value = value & LU52I_B; ++ codescost.curr_value = value; + cost++; + } + } +@@ -2910,6 +2916,9 @@ loongarch_move_integer (rtx temp, rtx dest, unsigned HOST_WIDE_INT value) + else + x = force_reg (mode, x); + ++ set_unique_reg_note (get_last_insn (), REG_EQUAL, ++ GEN_INT (codesi-1.curr_value)); ++ + switch (codesi.method) + { + case METHOD_NORMAL: +@@ -2917,22 +2926,17 @@ loongarch_move_integer (rtx temp, rtx dest, unsigned HOST_WIDE_INT value) + GEN_INT (codesi.value)); + break; + case METHOD_LU32I: +- emit_insn ( +- gen_rtx_SET (x, +- gen_rtx_IOR (DImode, +- gen_rtx_ZERO_EXTEND ( +- DImode, gen_rtx_SUBREG (SImode, x, 0)), +- GEN_INT (codesi.value)))); ++ gcc_assert (mode == DImode); ++ x = gen_rtx_IOR (DImode, ++ gen_rtx_ZERO_EXTEND (DImode, ++ gen_rtx_SUBREG (SImode, x, 0)), ++ GEN_INT (codesi.value)); + break; + case METHOD_LU52I: +- emit_insn (gen_lu52i_d (x, x, GEN_INT (0xfffffffffffff), +- GEN_INT (codesi.value))); +- break; +- case METHOD_INSV: +- emit_insn ( +- gen_rtx_SET (gen_rtx_ZERO_EXTRACT (DImode, x, GEN_INT (20), +- GEN_INT (32)), +- gen_rtx_REG (DImode, 0))); ++ gcc_assert (mode == DImode); ++ x = gen_rtx_IOR (DImode, ++ gen_rtx_AND (DImode, x, GEN_INT (0xfffffffffffff)), ++ GEN_INT (codesi.value)); + break; + default: + gcc_unreachable (); +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 2fda53819..f61db66d5 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -1718,23 +1718,41 @@ + DONE; + }) + +-(define_insn "*movdi_32bit" ++(define_insn_and_split "*movdi_32bit" + (set (match_operand:DI 0 "nonimmediate_operand" "=r,r,r,w,*f,*f,*r,*m") + (match_operand:DI 1 "move_operand" "r,i,w,r,*J*r,*m,*f,*f")) + "!TARGET_64BIT + && (register_operand (operands0, DImode) + || reg_or_0_operand (operands1, DImode))" + { return loongarch_output_move (operands0, operands1); } ++ "CONST_INT_P (operands1) && REG_P (operands0) && GP_REG_P (REGNO ++ (operands0))" ++ (const_int 0) ++ " ++{ ++ loongarch_move_integer (operands0, operands0, INTVAL (operands1)); ++ DONE; ++} ++ " + (set_attr "move_type" "move,const,load,store,mgtf,fpload,mftg,fpstore") + (set_attr "mode" "DI")) + +-(define_insn "*movdi_64bit" ++(define_insn_and_split "*movdi_64bit" + (set (match_operand:DI 0 "nonimmediate_operand" "=r,r,r,w,*f,*f,*r,*m") + (match_operand:DI 1 "move_operand" "r,Yd,w,rJ,*r*J,*m,*f,*f")) + "TARGET_64BIT + && (register_operand (operands0, DImode) + || reg_or_0_operand (operands1, DImode))" + { return loongarch_output_move (operands0, operands1); } ++ "CONST_INT_P (operands1) && REG_P (operands0) && GP_REG_P (REGNO ++ (operands0))" ++ (const_int 0) ++ " ++{ ++ loongarch_move_integer (operands0, operands0, INTVAL (operands1)); ++ DONE; ++} ++ " + (set_attr "move_type" "move,const,load,store,mgtf,fpload,mftg,fpstore") + (set_attr "mode" "DI")) + +@@ -1749,12 +1767,21 @@ + DONE; + }) + +-(define_insn "*movsi_internal" ++(define_insn_and_split "*movsi_internal" + (set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,w,*f,*f,*r,*m,*r,*z") + (match_operand:SI 1 "move_operand" "r,Yd,w,rJ,*r*J,*m,*f,*f,*z,*r")) + "(register_operand (operands0, SImode) + || reg_or_0_operand (operands1, SImode))" + { return loongarch_output_move (operands0, operands1); } ++ "CONST_INT_P (operands1) && REG_P (operands0) && GP_REG_P (REGNO ++ (operands0))" ++ (const_int 0) ++ " ++{ ++ loongarch_move_integer (operands0, operands0, INTVAL (operands1)); ++ DONE; ++} ++ " + (set_attr "move_type" "move,const,load,store,mgtf,fpload,mftg,fpstore,mftg,mgtf") + (set_attr "mode" "SI")) + +@@ -1774,12 +1801,21 @@ + DONE; + }) + +-(define_insn "*movhi_internal" ++(define_insn_and_split "*movhi_internal" + (set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,r,m,r,k") + (match_operand:HI 1 "move_operand" "r,Yd,I,m,rJ,k,rJ")) + "(register_operand (operands0, HImode) + || reg_or_0_operand (operands1, HImode))" + { return loongarch_output_move (operands0, operands1); } ++ "CONST_INT_P (operands1) && REG_P (operands0) && GP_REG_P (REGNO ++ (operands0))" ++ (const_int 0) ++ " ++{ ++ loongarch_move_integer (operands0, operands0, INTVAL (operands1)); ++ DONE; ++} ++ " + (set_attr "move_type" "move,const,const,load,store,load,store") + (set_attr "mode" "HI")) + +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index 8bd0c1376..58c3dc226 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -226,7 +226,7 @@ + switch (GET_CODE (op)) + { + case CONST_INT: +- return !splittable_const_int_operand (op, mode); ++ return true; + + case CONST: + case SYMBOL_REF: +diff --git a/gcc/testsuite/gcc.target/loongarch/imm-load.c b/gcc/testsuite/gcc.target/loongarch/imm-load.c +new file mode 100644 +index 000000000..c04ca3399 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/imm-load.c +@@ -0,0 +1,10 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O2 -fdump-rtl-split1" } */ ++ ++long int ++test (void) ++{ ++ return 0x1234567890abcdef; ++} ++/* { dg-final { scan-rtl-dump-times "scanning new insn with uid" 6 "split1" } } */ ++ +diff --git a/gcc/testsuite/gcc.target/loongarch/imm-load1.c b/gcc/testsuite/gcc.target/loongarch/imm-load1.c +new file mode 100644 +index 000000000..2ff029712 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/imm-load1.c +@@ -0,0 +1,26 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O2" } */ ++/* { dg-final { scan-assembler "test:.*lu52i\.d.*\n\taddi\.w.*\n\.L2:" } } */ ++ ++ ++extern long long b10; ++static inline long long ++repeat_bytes (void) ++{ ++ long long r = 0x0101010101010101; ++ ++ return r; ++} ++ ++static inline long long ++highbit_mask (long long m) ++{ ++ return m & repeat_bytes (); ++} ++ ++void test(long long *a) ++{ ++ for (int i = 0; i < 10; i++) ++ bi = highbit_mask (ai); ++ ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Optimize-switch-with-sign-extended-index.patch
Added
@@ -0,0 +1,114 @@ +From c6d4efda0fa064dfe1d3cc1b9abf8051a82cd74f Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Sat, 2 Sep 2023 10:59:55 +0800 +Subject: PATCH 056/124 LoongArch: Optimize switch with sign-extended index. + +The patch refers to the submission of RISCV +7bbce9b50302959286381d9177818642bceaf301. + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_extend_comparands): + In unsigned QImode test, check for sign extended subreg and/or + constant operands, and do a sign extension in that case. + * config/loongarch/loongarch.md (TARGET_64BIT): Define + template cbranchqi4. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/switch-qi.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 16 +++++++++++++--- + gcc/config/loongarch/loongarch.md | 10 +++++++--- + gcc/testsuite/gcc.target/loongarch/switch-qi.c | 16 ++++++++++++++++ + 3 files changed, 36 insertions(+), 6 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/switch-qi.c + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 7b48e3216..41d344b82 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -4221,11 +4221,21 @@ loongarch_allocate_fcc (machine_mode mode) + static void + loongarch_extend_comparands (rtx_code code, rtx *op0, rtx *op1) + { +- /* Comparisons consider all XLEN bits, so extend sub-XLEN values. */ ++ /* Comparisons consider all GRLEN bits, so extend sub-GRLEN values. */ + if (GET_MODE_SIZE (word_mode) > GET_MODE_SIZE (GET_MODE (*op0))) + { +- /* TODO: checkout It is more profitable to zero-extend QImode values. */ +- if (unsigned_condition (code) == code && GET_MODE (*op0) == QImode) ++ /* It is more profitable to zero-extend QImode values. But not if the ++ first operand has already been sign-extended, and the second one is ++ is a constant or has already been sign-extended also. */ ++ if (unsigned_condition (code) == code ++ && (GET_MODE (*op0) == QImode ++ && ! (GET_CODE (*op0) == SUBREG ++ && SUBREG_PROMOTED_VAR_P (*op0) ++ && SUBREG_PROMOTED_SIGNED_P (*op0) ++ && (CONST_INT_P (*op1) ++ || (GET_CODE (*op1) == SUBREG ++ && SUBREG_PROMOTED_VAR_P (*op1) ++ && SUBREG_PROMOTED_SIGNED_P (*op1)))))) + { + *op0 = gen_rtx_ZERO_EXTEND (word_mode, *op0); + if (CONST_INT_P (*op1)) +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index cf7441e0b..a5e9352ca 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -357,7 +357,7 @@ + ;; pointer-sized quantities. Exactly one of the two alternatives will match. + (define_mode_iterator P (SI "Pmode == SImode") (DI "Pmode == DImode")) + +-;; Likewise, but for XLEN-sized quantities. ++;; Likewise, but for GRLEN-sized quantities. + (define_mode_iterator X (SI "!TARGET_64BIT") (DI "TARGET_64BIT")) + + ;; 64-bit modes for which we provide move patterns. +@@ -2733,11 +2733,15 @@ + (set_attr "type" "branch")) + + ++;; Branches operate on GRLEN-sized quantities, but for LoongArch64 we accept ++;; QImode values so we can force zero-extension. ++(define_mode_iterator BR (QI "TARGET_64BIT") SI (DI "TARGET_64BIT")) ++ + (define_expand "cbranch<mode>4" + (set (pc) + (if_then_else (match_operator 0 "comparison_operator" +- (match_operand:GPR 1 "register_operand") +- (match_operand:GPR 2 "nonmemory_operand")) ++ (match_operand:BR 1 "register_operand") ++ (match_operand:BR 2 "nonmemory_operand")) + (label_ref (match_operand 3 "")) + (pc))) + "" +diff --git a/gcc/testsuite/gcc.target/loongarch/switch-qi.c b/gcc/testsuite/gcc.target/loongarch/switch-qi.c +new file mode 100644 +index 000000000..dd192fd49 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/switch-qi.c +@@ -0,0 +1,16 @@ ++/* { dg-do compile } */ ++/* { dg-options "-march=loongarch64 -mabi=lp64d" } */ ++/* { dg-final { scan-assembler-not "bstrpick" } } */ ++ ++/* Test for loongarch_extend_comparands patch. */ ++extern void asdf (int); ++void ++foo (signed char x) { ++ switch (x) { ++ case 0: asdf (10); break; ++ case 1: asdf (11); break; ++ case 2: asdf (12); break; ++ case 3: asdf (13); break; ++ case 4: asdf (14); break; ++ } ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Optimize-the-implementation-of-stack-check.patch
Added
@@ -0,0 +1,810 @@ +From d3615b555d6885dba298f7b339740be11cb65a8f Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Tue, 29 Nov 2022 16:06:12 +0800 +Subject: PATCH 033/124 LoongArch: Optimize the implementation of stack + check. + +The old stack check was performed before the stack was dropped, +which would cause the detection tool to report a memory leak. + +The current stack check scheme is as follows: + +'-fstack-clash-protection': +1. When the frame->total_size is smaller than the guard page size, + the stack is dropped according to the original scheme, and there + is no need to perform stack detection in the prologue. +2. When frame->total_size is greater than or equal to guard page size, + the first step to drop the stack is to drop the space required by + the caller-save registers. This space needs to save the caller-save + registers, so an implicit stack check is performed. + So just need to check the rest of the stack space. + +'-fstack-check': +There is no one-time stack drop and then page-by-page detection as +described in the document. It is also the same as +'-fstack-clash-protection', which is detected immediately after page drop. + +It is judged that when frame->total_size is not 0, only the size required +to save the s register is dropped for the first stack down. + +The test cases are referenced from aarch64. + +gcc/ChangeLog: + + * config/loongarch/linux.h (STACK_CHECK_MOVING_SP): + Define this macro to 1. + * config/loongarch/loongarch.cc (STACK_CLASH_PROTECTION_GUARD_SIZE): + Size of guard page. + (loongarch_first_stack_step): Return the size of the first drop stack + according to whether stack checking is performed. + (loongarch_emit_probe_stack_range): Adjust the method of stack checking in prologue. + (loongarch_output_probe_stack_range): Delete useless code. + (loongarch_expand_prologue): Adjust the method of stack checking in prologue. + (loongarch_option_override_internal): Enforce that interval is the same + size as size so the mid-end does the right thing. + * config/loongarch/loongarch.h (STACK_CLASH_MAX_UNROLL_PAGES): + New macro decide whether to loop stack detection. + +gcc/testsuite/ChangeLog: + + * lib/target-supports.exp: + * gcc.target/loongarch/stack-check-alloca-1.c: New test. + * gcc.target/loongarch/stack-check-alloca-2.c: New test. + * gcc.target/loongarch/stack-check-alloca-3.c: New test. + * gcc.target/loongarch/stack-check-alloca-4.c: New test. + * gcc.target/loongarch/stack-check-alloca-5.c: New test. + * gcc.target/loongarch/stack-check-alloca-6.c: New test. + * gcc.target/loongarch/stack-check-alloca.h: New test. + * gcc.target/loongarch/stack-check-cfa-1.c: New test. + * gcc.target/loongarch/stack-check-cfa-2.c: New test. + * gcc.target/loongarch/stack-check-prologue-1.c: New test. + * gcc.target/loongarch/stack-check-prologue-2.c: New test. + * gcc.target/loongarch/stack-check-prologue-3.c: New test. + * gcc.target/loongarch/stack-check-prologue-4.c: New test. + * gcc.target/loongarch/stack-check-prologue-5.c: New test. + * gcc.target/loongarch/stack-check-prologue-6.c: New test. + * gcc.target/loongarch/stack-check-prologue-7.c: New test. + * gcc.target/loongarch/stack-check-prologue.h: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/linux.h | 3 + + gcc/config/loongarch/loongarch.cc | 248 +++++++++++------- + gcc/config/loongarch/loongarch.h | 4 + + .../loongarch/stack-check-alloca-1.c | 15 ++ + .../loongarch/stack-check-alloca-2.c | 12 + + .../loongarch/stack-check-alloca-3.c | 12 + + .../loongarch/stack-check-alloca-4.c | 12 + + .../loongarch/stack-check-alloca-5.c | 13 + + .../loongarch/stack-check-alloca-6.c | 13 + + .../gcc.target/loongarch/stack-check-alloca.h | 15 ++ + .../gcc.target/loongarch/stack-check-cfa-1.c | 12 + + .../gcc.target/loongarch/stack-check-cfa-2.c | 12 + + .../loongarch/stack-check-prologue-1.c | 11 + + .../loongarch/stack-check-prologue-2.c | 11 + + .../loongarch/stack-check-prologue-3.c | 11 + + .../loongarch/stack-check-prologue-4.c | 11 + + .../loongarch/stack-check-prologue-5.c | 12 + + .../loongarch/stack-check-prologue-6.c | 11 + + .../loongarch/stack-check-prologue-7.c | 12 + + .../loongarch/stack-check-prologue.h | 5 + + gcc/testsuite/lib/target-supports.exp | 7 +- + 21 files changed, 361 insertions(+), 101 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-alloca-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-alloca-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-alloca-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-alloca-4.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-alloca-5.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-alloca-6.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-alloca.h + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue-4.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue-5.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue-6.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue-7.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/stack-check-prologue.h + +diff --git a/gcc/config/loongarch/linux.h b/gcc/config/loongarch/linux.h +index 110d0fab9..00039ac18 100644 +--- a/gcc/config/loongarch/linux.h ++++ b/gcc/config/loongarch/linux.h +@@ -48,3 +48,6 @@ along with GCC; see the file COPYING3. If not see + #define STACK_CHECK_PROTECT (TARGET_64BIT ? 16 * 1024 : 12 * 1024) + + #define TARGET_ASM_FILE_END file_end_indicate_exec_stack ++ ++/* The stack pointer needs to be moved while checking the stack. */ ++#define STACK_CHECK_MOVING_SP 1 +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index f45a49f90..e59edc4cd 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -257,6 +257,10 @@ const char *const + loongarch_fp_conditions16= {LARCH_FP_CONDITIONS (STRINGIFY)}; + #undef STRINGIFY + ++/* Size of guard page. */ ++#define STACK_CLASH_PROTECTION_GUARD_SIZE \ ++ (1 << param_stack_clash_protection_guard_size) ++ + /* Implement TARGET_FUNCTION_ARG_BOUNDARY. Every parameter gets at + least PARM_BOUNDARY bits of alignment, but will be given anything up + to PREFERRED_STACK_BOUNDARY bits if the type requires it. */ +@@ -1069,11 +1073,20 @@ loongarch_restore_reg (rtx reg, rtx mem) + static HOST_WIDE_INT + loongarch_first_stack_step (struct loongarch_frame_info *frame) + { ++ HOST_WIDE_INT min_first_step ++ = LARCH_STACK_ALIGN (frame->total_size - frame->fp_sp_offset); ++ ++ /* When stack checking is required, if the sum of frame->total_size ++ and stack_check_protect is greater than stack clash protection guard ++ size, then return min_first_step. */ ++ if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK ++ || (flag_stack_clash_protection ++ && frame->total_size > STACK_CLASH_PROTECTION_GUARD_SIZE)) ++ return min_first_step; ++ + if (IMM12_OPERAND (frame->total_size)) + return frame->total_size; + +- HOST_WIDE_INT min_first_step +- = LARCH_STACK_ALIGN (frame->total_size - frame->fp_sp_offset); + HOST_WIDE_INT max_first_step = IMM_REACH / 2 - PREFERRED_STACK_BOUNDARY / 8; + HOST_WIDE_INT min_second_step = frame->total_size - max_first_step; + gcc_assert (min_first_step <= max_first_step); +@@ -1106,103 +1119,109 @@ loongarch_emit_stack_tie (void) + static void + loongarch_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size) + { +- /* See if we have a constant small number of probes to generate. If so, +- that's the easy case. */ +- if ((TARGET_64BIT && (first + size <= 32768)) +- || (!TARGET_64BIT && (first + size <= 2048))) +- { +- HOST_WIDE_INT i; ++ HOST_WIDE_INT rounded_size; ++ HOST_WIDE_INT interval; + +- /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until +- it exceeds SIZE. If only one probe is needed, this will not +- generate any code. Then probe at FIRST + SIZE. */ +- for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL) +- emit_stack_probe (plus_constant (Pmode, stack_pointer_rtx, +- -(first + i))); ++ if (flag_stack_clash_protection) ++ interval = STACK_CLASH_PROTECTION_GUARD_SIZE; ++ else ++ interval = PROBE_INTERVAL; + +- emit_stack_probe (plus_constant (Pmode, stack_pointer_rtx, +- -(first + size))); +- } ++ rtx r12 = LARCH_PROLOGUE_TEMP2 (Pmode); ++ rtx r14 = LARCH_PROLOGUE_TEMP3 (Pmode); + +- /* Otherwise, do the same as above, but in a loop. Note that we must be +- extra careful with variables wrapping around because we might be at +- the very top (or the very bottom) of the address space and we have +- to be able to handle this case properly; in particular, we use an +- equality test for the loop condition. */ +- else +- { +- HOST_WIDE_INT rounded_size; +- rtx r13 = LARCH_PROLOGUE_TEMP (Pmode); +- rtx r12 = LARCH_PROLOGUE_TEMP2 (Pmode); +- rtx r14 = LARCH_PROLOGUE_TEMP3 (Pmode); ++ size = size + first; + +- /* Sanity check for the addressing mode we're going to use. */ +- gcc_assert (first <= 16384); ++ /* Sanity check for the addressing mode we're going to use. */ ++ gcc_assert (first <= 16384); + ++ /* Step 1: round SIZE to the previous multiple of the interval. */ + +- /* Step 1: round SIZE to the previous multiple of the interval. */ ++ rounded_size = ROUND_DOWN (size, interval); + +- rounded_size = ROUND_DOWN (size, PROBE_INTERVAL); ++ /* Step 2: compute initial and final value of the loop counter. */ + +- /* TEST_ADDR = SP + FIRST */ +- if (first != 0) +- { +- emit_move_insn (r14, GEN_INT (first)); +- emit_insn (gen_rtx_SET (r13, gen_rtx_MINUS (Pmode, +- stack_pointer_rtx, +- r14))); +- } +- else +- emit_move_insn (r13, stack_pointer_rtx); ++ emit_move_insn (r14, GEN_INT (interval)); ++ ++ /* If rounded_size is zero, it means that the space requested by ++ the local variable is less than the interval, and there is no ++ need to display and detect the allocated space. */ ++ if (rounded_size != 0) ++ { ++ /* Step 3: the loop ++ ++ do ++ { ++ TEST_ADDR = TEST_ADDR + PROBE_INTERVAL ++ probe at TEST_ADDR ++ } ++ while (TEST_ADDR != LAST_ADDR) + +- /* Step 2: compute initial and final value of the loop counter. */ ++ probes at FIRST + N * PROBE_INTERVAL for values of N from 1 ++ until it is equal to ROUNDED_SIZE. */ + +- emit_move_insn (r14, GEN_INT (PROBE_INTERVAL)); +- /* LAST_ADDR = SP + FIRST + ROUNDED_SIZE. */ +- if (rounded_size == 0) +- emit_move_insn (r12, r13); ++ if (rounded_size <= STACK_CLASH_MAX_UNROLL_PAGES * interval) ++ { ++ for (HOST_WIDE_INT i = 0; i < rounded_size; i += interval) ++ { ++ emit_insn (gen_rtx_SET (stack_pointer_rtx, ++ gen_rtx_MINUS (Pmode, ++ stack_pointer_rtx, ++ r14))); ++ emit_move_insn (gen_rtx_MEM (Pmode, ++ gen_rtx_PLUS (Pmode, ++ stack_pointer_rtx, ++ const0_rtx)), ++ const0_rtx); ++ emit_insn (gen_blockage ()); ++ } ++ dump_stack_clash_frame_info (PROBE_INLINE, size != rounded_size); ++ } + else + { + emit_move_insn (r12, GEN_INT (rounded_size)); +- emit_insn (gen_rtx_SET (r12, gen_rtx_MINUS (Pmode, r13, r12))); +- /* Step 3: the loop +- +- do +- { +- TEST_ADDR = TEST_ADDR + PROBE_INTERVAL +- probe at TEST_ADDR +- } +- while (TEST_ADDR != LAST_ADDR) +- +- probes at FIRST + N * PROBE_INTERVAL for values of N from 1 +- until it is equal to ROUNDED_SIZE. */ +- +- emit_insn (gen_probe_stack_range (Pmode, r13, r13, r12, r14)); ++ emit_insn (gen_rtx_SET (r12, ++ gen_rtx_MINUS (Pmode, ++ stack_pointer_rtx, ++ r12))); ++ ++ emit_insn (gen_probe_stack_range (Pmode, stack_pointer_rtx, ++ stack_pointer_rtx, r12, r14)); ++ emit_insn (gen_blockage ()); ++ dump_stack_clash_frame_info (PROBE_LOOP, size != rounded_size); + } ++ } ++ else ++ dump_stack_clash_frame_info (NO_PROBE_SMALL_FRAME, true); ++ + +- /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time +- that SIZE is equal to ROUNDED_SIZE. */ ++ /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time ++ that SIZE is equal to ROUNDED_SIZE. */ + +- if (size != rounded_size) ++ if (size != rounded_size) ++ { ++ if (size - rounded_size >= 2048) + { +- if (TARGET_64BIT) +- emit_stack_probe (plus_constant (Pmode, r12, rounded_size - size)); +- else +- { +- HOST_WIDE_INT i; +- for (i = 2048; i < (size - rounded_size); i += 2048) +- { +- emit_stack_probe (plus_constant (Pmode, r12, -i)); +- emit_insn (gen_rtx_SET (r12, +- plus_constant (Pmode, r12, -2048))); +- } +- rtx r1 = plus_constant (Pmode, r12, +- -(size - rounded_size - i + 2048)); +- emit_stack_probe (r1); +- } ++ emit_move_insn (r14, GEN_INT (size - rounded_size)); ++ emit_insn (gen_rtx_SET (stack_pointer_rtx, ++ gen_rtx_MINUS (Pmode, ++ stack_pointer_rtx, ++ r14))); + } ++ else ++ emit_insn (gen_rtx_SET (stack_pointer_rtx, ++ gen_rtx_PLUS (Pmode, ++ stack_pointer_rtx, ++ GEN_INT (rounded_size - size)))); + } + ++ if (first) ++ { ++ emit_move_insn (r12, GEN_INT (first)); ++ emit_insn (gen_rtx_SET (stack_pointer_rtx, ++ gen_rtx_PLUS (Pmode, ++ stack_pointer_rtx, r12))); ++ } + /* Make sure nothing is scheduled before we are done. */ + emit_insn (gen_blockage ()); + } +@@ -1223,7 +1242,6 @@ loongarch_output_probe_stack_range (rtx reg1, rtx reg2, rtx reg3) + + /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL. */ + xops0 = reg1; +- xops1 = GEN_INT (-PROBE_INTERVAL); + xops2 = reg3; + if (TARGET_64BIT) + output_asm_insn ("sub.d\t%0,%0,%2", xops); +@@ -1249,28 +1267,11 @@ loongarch_expand_prologue (void) + { + struct loongarch_frame_info *frame = &cfun->machine->frame; + HOST_WIDE_INT size = frame->total_size; +- HOST_WIDE_INT tmp; + rtx insn; + + if (flag_stack_usage_info) + current_function_static_stack_size = size; + +- if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK +- || flag_stack_clash_protection) +- { +- if (crtl->is_leaf && !cfun->calls_alloca) +- { +- if (size > PROBE_INTERVAL && size > get_stack_check_protect ()) +- { +- tmp = size - get_stack_check_protect (); +- loongarch_emit_probe_stack_range (get_stack_check_protect (), +- tmp); +- } +- } +- else if (size > 0) +- loongarch_emit_probe_stack_range (get_stack_check_protect (), size); +- } +- + /* Save the registers. */ + if ((frame->mask | frame->fmask) != 0) + { +@@ -1283,7 +1284,6 @@ loongarch_expand_prologue (void) + loongarch_for_each_saved_reg (size, loongarch_save_reg); + } + +- + /* Set up the frame pointer, if we're using one. */ + if (frame_pointer_needed) + { +@@ -1294,7 +1294,45 @@ loongarch_expand_prologue (void) + loongarch_emit_stack_tie (); + } + +- /* Allocate the rest of the frame. */ ++ if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK ++ || flag_stack_clash_protection) ++ { ++ HOST_WIDE_INT first = get_stack_check_protect (); ++ ++ if (frame->total_size == 0) ++ { ++ /* do nothing. */ ++ dump_stack_clash_frame_info (NO_PROBE_NO_FRAME, false); ++ return; ++ } ++ ++ if (crtl->is_leaf && !cfun->calls_alloca) ++ { ++ HOST_WIDE_INT interval; ++ ++ if (flag_stack_clash_protection) ++ interval = STACK_CLASH_PROTECTION_GUARD_SIZE; ++ else ++ interval = PROBE_INTERVAL; ++ ++ if (size > interval && size > first) ++ loongarch_emit_probe_stack_range (first, size - first); ++ else ++ loongarch_emit_probe_stack_range (first, size); ++ } ++ else ++ loongarch_emit_probe_stack_range (first, size); ++ ++ if (size > 0) ++ { ++ /* Describe the effect of the previous instructions. */ ++ insn = plus_constant (Pmode, stack_pointer_rtx, -size); ++ insn = gen_rtx_SET (stack_pointer_rtx, insn); ++ loongarch_set_frame_expr (insn); ++ } ++ return; ++ } ++ + if (size > 0) + { + if (IMM12_OPERAND (-size)) +@@ -1305,7 +1343,8 @@ loongarch_expand_prologue (void) + } + else + { +- loongarch_emit_move (LARCH_PROLOGUE_TEMP (Pmode), GEN_INT (-size)); ++ loongarch_emit_move (LARCH_PROLOGUE_TEMP (Pmode), ++ GEN_INT (-size)); + emit_insn (gen_add3_insn (stack_pointer_rtx, stack_pointer_rtx, + LARCH_PROLOGUE_TEMP (Pmode))); + +@@ -6162,6 +6201,15 @@ loongarch_option_override_internal (struct gcc_options *opts) + gcc_unreachable (); + } + ++ /* Validate the guard size. */ ++ int guard_size = param_stack_clash_protection_guard_size; ++ ++ /* Enforce that interval is the same size as size so the mid-end does the ++ right thing. */ ++ SET_OPTION_IF_UNSET (opts, &global_options_set, ++ param_stack_clash_protection_probe_interval, ++ guard_size); ++ + loongarch_init_print_operand_punct (); + + /* Set up array to map GCC register number to debug register number. +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index a52a81adf..392597943 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -668,6 +668,10 @@ enum reg_class + + #define STACK_BOUNDARY (TARGET_ABI_LP64 ? 128 : 64) + ++/* This value controls how many pages we manually unroll the loop for when ++ generating stack clash probes. */ ++#define STACK_CLASH_MAX_UNROLL_PAGES 4 ++ + /* Symbolic macros for the registers used to return integer and floating + point values. */ + +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-1.c b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-1.c +new file mode 100644 +index 000000000..6ee589c4b +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-1.c +@@ -0,0 +1,15 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-require-effective-target alloca } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE y ++#include "stack-check-alloca.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r\d{1,2},-8} 1 } } */ ++/* { dg-final { scan-assembler-times {stx\.d\t\$r0,\$r3,\$r12} 1 } } */ ++ ++/* Dynamic alloca, expect loop, and 1 probes with top at sp. ++ 1st probe is inside the loop for the full guard-size allocations, second ++ probe is for the case where residual is zero. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-2.c b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-2.c +new file mode 100644 +index 000000000..8deaa5873 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-2.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-require-effective-target alloca } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 0 ++#include "stack-check-alloca.h" ++ ++/* { dg-final { scan-assembler-not {stp*t*r*\.d\t\$r0,\$r3,4088} } } */ ++ ++/* Alloca of 0 should emit no probes, boundary condition. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-3.c b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-3.c +new file mode 100644 +index 000000000..e326ba9a0 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-3.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-require-effective-target alloca } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 100 ++#include "stack-check-alloca.h" ++ ++/* { dg-final { scan-assembler-times {st\.d\t\$r0,\$r3,104} 1 } } */ ++ ++/* Alloca is less than guard-size, 1 probe at the top of the new allocation. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-4.c b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-4.c +new file mode 100644 +index 000000000..b9f7572de +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-4.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-require-effective-target alloca } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 64 * 1024 ++#include "stack-check-alloca.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r\d{1,2},-8} 1 } } */ ++ ++/* Alloca is exactly one guard-size, 1 probe expected at top. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-5.c b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-5.c +new file mode 100644 +index 000000000..0ff6e493f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-5.c +@@ -0,0 +1,13 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-require-effective-target alloca } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 65 * 1024 ++#include "stack-check-alloca.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r\d{1,2},-8} 1 } } */ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r3,1016} 1 } } */ ++ ++/* Alloca is more than one guard-page. 2 probes expected. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-6.c b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-6.c +new file mode 100644 +index 000000000..c5cf74fcb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca-6.c +@@ -0,0 +1,13 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-require-effective-target alloca } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 127 * 64 * 1024 ++#include "stack-check-alloca.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r\d{1,2},-8} 1 } } */ ++ ++/* Large alloca of a constant amount which is a multiple of a guard-size. ++ Loop expected with top probe. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-alloca.h b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca.h +new file mode 100644 +index 000000000..8c75f6c0f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-alloca.h +@@ -0,0 +1,15 @@ ++ ++/* Avoid inclusion of alloca.h, unavailable on some systems. */ ++#define alloca __builtin_alloca ++ ++__attribute__((noinline, noipa)) ++void g (char* ptr, int y) ++{ ++ ptry = '\0'; ++} ++ ++void f_caller (int y) ++{ ++ char* pStr = alloca(SIZE); ++ g (pStr, y); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c +new file mode 100644 +index 000000000..f0c6877fc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16 -funwind-tables" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 128*1024 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 131088} 1 } } */ ++/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 0} 1 } } */ ++ ++/* Checks that the CFA notes are correct for every sp adjustment. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c +new file mode 100644 +index 000000000..c6e07bc56 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16 -funwind-tables" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 1280*1024 + 512 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 1311248} 1 } } */ ++/* { dg-final { scan-assembler-times {\.cfi_def_cfa_offset 0} 1 } } */ ++ ++/* Checks that the CFA notes are correct for every sp adjustment. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-1.c b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-1.c +new file mode 100644 +index 000000000..351bc1f61 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-1.c +@@ -0,0 +1,11 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 128 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r3,0} 0 } } */ ++ ++/* SIZE is smaller than guard-size so no probe expected. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-2.c b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-2.c +new file mode 100644 +index 000000000..6bba659a3 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-2.c +@@ -0,0 +1,11 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 63 * 1024 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*.d\t\$r0,\$r3,0} 0 } } */ ++ ++/* SIZE is smaller than guard-size so no probe expected. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-3.c b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-3.c +new file mode 100644 +index 000000000..164956c37 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-3.c +@@ -0,0 +1,11 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 64 * 1024 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r3,0} 1 } } */ ++ ++/* SIZE is equal to guard-size, 1 probe expected, boundary condition. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-4.c b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-4.c +new file mode 100644 +index 000000000..f53da6b0d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-4.c +@@ -0,0 +1,11 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 65 * 1024 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r3,0} 1 } } */ ++ ++/* SIZE is more than guard-size 1 probe expected. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-5.c b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-5.c +new file mode 100644 +index 000000000..c092317ea +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-5.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 127 * 1024 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r3,0} 1 } } */ ++ ++/* SIZE is more than 1x guard-size and remainder small than guard-size, ++ 1 probe expected, unrolled, no loop. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-6.c b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-6.c +new file mode 100644 +index 000000000..70a2f53f6 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-6.c +@@ -0,0 +1,11 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 128 * 1024 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*\.d\t\$r0,\$r3,0} 2 } } */ ++ ++/* SIZE is more than 2x guard-size and no remainder, unrolled, no loop. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-7.c b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-7.c +new file mode 100644 +index 000000000..e2df89acc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue-7.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16" } */ ++/* { dg-require-effective-target supports_stack_clash_protection } */ ++/* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ ++ ++#define SIZE 6 * 64 * 1024 ++#include "stack-check-prologue.h" ++ ++/* { dg-final { scan-assembler-times {stp*t*r*.d\t\$r0,\$r3,0} 1 } } */ ++ ++/* SIZE is more than 4x guard-size and no remainder, 1 probe expected in a loop ++ and no residual probe. */ +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-prologue.h b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue.h +new file mode 100644 +index 000000000..b7e06aedb +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-prologue.h +@@ -0,0 +1,5 @@ ++int f_test (int x) ++{ ++ char arrSIZE; ++ return arrx; ++} +diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp +index c858bd93b..3a326ea1c 100644 +--- a/gcc/testsuite/lib/target-supports.exp ++++ b/gcc/testsuite/lib/target-supports.exp +@@ -11292,7 +11292,8 @@ proc check_effective_target_supports_stack_clash_protection { } { + + if { istarget x86_64-*-* || istarget i?86-*-* + || istarget powerpc*-*-* || istarget rs6000*-*-* +- || istarget aarch64*-** || istarget s390*-*-* } { ++ || istarget aarch64*-** || istarget s390*-*-* ++ || istarget loongarch64*-** } { + return 1 + } + return 0 +@@ -11343,6 +11344,10 @@ proc check_effective_target_caller_implicit_probes { } { + return 1; + } + ++ if { istarget loongarch64*-*-* } { ++ return 1; ++ } ++ + return 0 + } + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Optimized-multiply-instruction-generation.patch
Added
@@ -0,0 +1,232 @@ +From aa1dc79c9a5ff3df241a94cbfb1c857cfa89c686 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Tue, 5 Sep 2023 11:09:03 +0800 +Subject: PATCH 074/124 LoongArch: Optimized multiply instruction generation. + + 1. Can generate mulh.wu instruction. + 2. Can generate mulw.d.wu instruction. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (mulsidi3_64bit): + Field unsigned extension support. + (<u>muldi3_highpart): Modify template name. + (<u>mulsi3_highpart): Likewise. + (<u>mulsidi3_64bit): Field unsigned extension support. + (<su>muldi3_highpart): Modify muldi3_highpart to + smuldi3_highpart. + (<su>mulsi3_highpart): Modify mulsi3_highpart to + smulsi3_highpart. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/mulw_d_wu.c: New test. + * gcc.target/loongarch/smuldi3_highpart.c: New test. + * gcc.target/loongarch/smulsi3_highpart.c: New test. + * gcc.target/loongarch/umulsi3_highpart.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 66 ++++++++++++------- + .../gcc.target/loongarch/mulw_d_wu.c | 9 +++ + .../gcc.target/loongarch/smuldi3_highpart.c | 13 ++++ + .../gcc.target/loongarch/smulsi3_highpart.c | 15 +++++ + .../gcc.target/loongarch/umulsi3_highpart.c | 14 ++++ + 5 files changed, 94 insertions(+), 23 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/mulw_d_wu.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/smuldi3_highpart.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/smulsi3_highpart.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/umulsi3_highpart.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 11c18bf15..264cd325c 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -750,15 +750,6 @@ + (set_attr "type" "imul") + (set_attr "mode" "<MODE>")) + +-(define_insn "mulsidi3_64bit" +- (set (match_operand:DI 0 "register_operand" "=r") +- (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "r")) +- (sign_extend:DI (match_operand:SI 2 "register_operand" "r")))) +- "TARGET_64BIT" +- "mulw.d.w\t%0,%1,%2" +- (set_attr "type" "imul") +- (set_attr "mode" "DI")) +- + (define_insn "*mulsi3_extended" + (set (match_operand:DI 0 "register_operand" "=r") + (sign_extend:DI +@@ -787,14 +778,14 @@ + emit_insn (gen_muldi3 (low, operands1, operands2)); + + rtx high = gen_reg_rtx (DImode); +- emit_insn (gen_<u>muldi3_highpart (high, operands1, operands2)); ++ emit_insn (gen_<su>muldi3_highpart (high, operands1, operands2)); + + emit_move_insn (gen_lowpart (DImode, operands0), low); + emit_move_insn (gen_highpart (DImode, operands0), high); + DONE; + }) + +-(define_insn "<u>muldi3_highpart" ++(define_insn "<su>muldi3_highpart" + (set (match_operand:DI 0 "register_operand" "=r") + (truncate:DI + (lshiftrt:TI +@@ -809,22 +800,34 @@ + (set_attr "mode" "DI")) + + (define_expand "<u>mulsidi3" +- (set (match_operand:DI 0 "register_operand" "=r") ++ (set (match_operand:DI 0 "register_operand") + (mult:DI (any_extend:DI +- (match_operand:SI 1 "register_operand" " r")) ++ (match_operand:SI 1 "register_operand")) + (any_extend:DI +- (match_operand:SI 2 "register_operand" " r")))) +- "!TARGET_64BIT" ++ (match_operand:SI 2 "register_operand")))) ++ "" + { +- rtx temp = gen_reg_rtx (SImode); +- emit_insn (gen_mulsi3 (temp, operands1, operands2)); +- emit_insn (gen_<u>mulsi3_highpart (loongarch_subword (operands0, true), +- operands1, operands2)); +- emit_insn (gen_movsi (loongarch_subword (operands0, false), temp)); +- DONE; ++ if (!TARGET_64BIT) ++ { ++ rtx temp = gen_reg_rtx (SImode); ++ emit_insn (gen_mulsi3 (temp, operands1, operands2)); ++ emit_insn (gen_<su>mulsi3_highpart (loongarch_subword (operands0, true), ++ operands1, operands2)); ++ emit_insn (gen_movsi (loongarch_subword (operands0, false), temp)); ++ DONE; ++ } + }) + +-(define_insn "<u>mulsi3_highpart" ++(define_insn "<u>mulsidi3_64bit" ++ (set (match_operand:DI 0 "register_operand" "=r") ++ (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand" "r")) ++ (any_extend:DI (match_operand:SI 2 "register_operand" "r")))) ++ "TARGET_64BIT" ++ "mulw.d.w<u>\t%0,%1,%2" ++ (set_attr "type" "imul") ++ (set_attr "mode" "DI")) ++ ++(define_insn "<su>mulsi3_highpart" + (set (match_operand:SI 0 "register_operand" "=r") + (truncate:SI + (lshiftrt:DI +@@ -833,11 +836,28 @@ + (any_extend:DI + (match_operand:SI 2 "register_operand" " r"))) + (const_int 32)))) +- "!TARGET_64BIT" ++ "" + "mulh.w<u>\t%0,%1,%2" + (set_attr "type" "imul") + (set_attr "mode" "SI")) + ++;; Under the LoongArch architecture, the mulh.wu instruction performs ++;; sign extension by default, so the sign extension instruction can be ++;; eliminated. ++(define_peephole ++ (set (match_operand:SI 0 "register_operand") ++ (truncate:SI ++ (lshiftrt:DI ++ (mult:DI (any_extend:DI ++ (match_operand:SI 1 "register_operand")) ++ (any_extend:DI ++ (match_operand:SI 2 "register_operand"))) ++ (const_int 32)))) ++ (set (match_operand:DI 3 "register_operand") ++ (sign_extend:DI (match_dup 0))) ++ "TARGET_64BIT && REGNO (operands0) == REGNO (operands3)" ++ "mulh.w<u>\t%0,%1,%2") ++ + ;; + ;; .................... + ;; +diff --git a/gcc/testsuite/gcc.target/loongarch/mulw_d_wu.c b/gcc/testsuite/gcc.target/loongarch/mulw_d_wu.c +new file mode 100644 +index 000000000..16163d667 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/mulw_d_wu.c +@@ -0,0 +1,9 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d" } */ ++/* { dg-final { scan-assembler "mulw.d.wu" } } */ ++ ++__attribute__((noipa, noinline)) unsigned long ++f(unsigned long a, unsigned long b) ++{ ++ return (unsigned long)(unsigned int)a * (unsigned long)(unsigned int)b; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/smuldi3_highpart.c b/gcc/testsuite/gcc.target/loongarch/smuldi3_highpart.c +new file mode 100644 +index 000000000..6f5c686ca +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/smuldi3_highpart.c +@@ -0,0 +1,13 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O2 -fdump-rtl-expand-all" } */ ++ ++typedef int TI __attribute ((mode(TI))); ++typedef int DI __attribute__((mode(DI))); ++ ++DI ++test (DI x, DI y) ++{ ++ return ((TI)x * y) >> 64; ++} ++ ++/* { dg-final { scan-rtl-dump "highparttmp" "expand" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/smulsi3_highpart.c b/gcc/testsuite/gcc.target/loongarch/smulsi3_highpart.c +new file mode 100644 +index 000000000..c4dbf8afc +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/smulsi3_highpart.c +@@ -0,0 +1,15 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -fdump-rtl-expand-all" } */ ++ ++typedef unsigned int DI __attribute__((mode(DI))); ++typedef unsigned int SI __attribute__((mode(SI))); ++ ++SI ++f (SI x, SI y) ++{ ++ return ((DI) x * y) >> 32; ++} ++ ++/* { dg-final { scan-rtl-dump "highparttmp" "expand" } } */ ++/* { dg-final { scan-assembler "mulh\\.w" } } */ ++/* { dg-final { scan-assembler-not "slli\\.w" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/umulsi3_highpart.c b/gcc/testsuite/gcc.target/loongarch/umulsi3_highpart.c +new file mode 100644 +index 000000000..e208803e2 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/umulsi3_highpart.c +@@ -0,0 +1,14 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++ ++typedef unsigned int DI __attribute__((mode(DI))); ++typedef unsigned int SI __attribute__((mode(SI))); ++ ++SI ++f (SI x, SI y) ++{ ++ return ((DI) x * y) >> 32; ++} ++ ++/* { dg-final { scan-assembler "mulh\\.wu" } } */ ++/* { dg-final { scan-assembler-not "slli\\.w" } } */ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Prepare-static-PIE-support.patch
Added
@@ -0,0 +1,44 @@ +From aa2d9e0e1dc4bf0b612618cf0e3fcea514f92f95 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 13 Sep 2022 23:21:39 +0800 +Subject: PATCH 018/124 LoongArch: Prepare static PIE support + +Static PIE allows us to extend the ASLR to cover static executables and +it's not too difficult to support it. On GCC side, we just pass a group +of options to the linker, like other ports with static PIE support. + +The real implementation of static PIE (rcrt1.o) will be added into Glibc +later. + +gcc/ChangeLog: + + * config/loongarch/gnu-user.h (GNU_USER_TARGET_LINK_SPEC): For + -static-pie, pass -static -pie --no-dynamic-linker -z text to + the linker, and do not pass --dynamic-linker. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/gnu-user.h | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +diff --git a/gcc/config/loongarch/gnu-user.h b/gcc/config/loongarch/gnu-user.h +index 664dc9206..c5b1afe53 100644 +--- a/gcc/config/loongarch/gnu-user.h ++++ b/gcc/config/loongarch/gnu-user.h +@@ -40,8 +40,10 @@ along with GCC; see the file COPYING3. If not see + #undef GNU_USER_TARGET_LINK_SPEC + #define GNU_USER_TARGET_LINK_SPEC \ + "%{G*} %{shared} -m " GNU_USER_LINK_EMULATION \ +- "%{!shared: %{static} %{!static: %{rdynamic:-export-dynamic} " \ +- "-dynamic-linker " GNU_USER_DYNAMIC_LINKER "}}" ++ "%{!shared: %{static} " \ ++ "%{!static: %{!static-pie: %{rdynamic:-export-dynamic} " \ ++ "-dynamic-linker " GNU_USER_DYNAMIC_LINKER "}} " \ ++ "%{static-pie: -static -pie --no-dynamic-linker -z text}}" + + + /* Similar to standard Linux, but adding -ffast-math support. */ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Provide-fmin-fmax-RTL-pattern.patch
Added
@@ -0,0 +1,100 @@ +From b065c84206cdf463a377ca28f719dae7acbed0f7 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 16 Aug 2022 15:34:36 +0800 +Subject: PATCH 009/124 LoongArch: Provide fmin/fmax RTL pattern + +We already had smin/smax RTL pattern using fmin/fmax instruction. But +for smin/smax, it's unspecified what will happen if either operand is +NaN. So we would generate calls to libc fmin/fmax functions with +-fno-finite-math-only (the default for all optimization levels expect +-Ofast). + +But, LoongArch fmin/fmax instruction is IEEE-754-2008 conformant so we +can also use the instruction for fmin/fmax pattern and avoid the library +function call. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (fmax<mode>3): New RTL pattern. + (fmin<mode>3): Likewise. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/fmax-fmin.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 18 +++++++++++ + .../gcc.target/loongarch/fmax-fmin.c | 30 +++++++++++++++++++ + 2 files changed, 48 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/fmax-fmin.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 6b6df22a5..8e8868de9 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -1023,6 +1023,24 @@ + (set_attr "type" "fmove") + (set_attr "mode" "<MODE>")) + ++(define_insn "fmax<mode>3" ++ (set (match_operand:ANYF 0 "register_operand" "=f") ++ (smax:ANYF (match_operand:ANYF 1 "register_operand" "f") ++ (match_operand:ANYF 2 "register_operand" "f"))) ++ "" ++ "fmax.<fmt>\t%0,%1,%2" ++ (set_attr "type" "fmove") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "fmin<mode>3" ++ (set (match_operand:ANYF 0 "register_operand" "=f") ++ (smin:ANYF (match_operand:ANYF 1 "register_operand" "f") ++ (match_operand:ANYF 2 "register_operand" "f"))) ++ "" ++ "fmin.<fmt>\t%0,%1,%2" ++ (set_attr "type" "fmove") ++ (set_attr "mode" "<MODE>")) ++ + (define_insn "smaxa<mode>3" + (set (match_operand:ANYF 0 "register_operand" "=f") + (if_then_else:ANYF +diff --git a/gcc/testsuite/gcc.target/loongarch/fmax-fmin.c b/gcc/testsuite/gcc.target/loongarch/fmax-fmin.c +new file mode 100644 +index 000000000..92cf8a150 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/fmax-fmin.c +@@ -0,0 +1,30 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mdouble-float -fno-finite-math-only" } */ ++/* { dg-final { scan-assembler "fmin\\.s" } } */ ++/* { dg-final { scan-assembler "fmin\\.d" } } */ ++/* { dg-final { scan-assembler "fmax\\.s" } } */ ++/* { dg-final { scan-assembler "fmax\\.d" } } */ ++ ++double ++_fmax(double a, double b) ++{ ++ return __builtin_fmax(a, b); ++} ++ ++float ++_fmaxf(float a, float b) ++{ ++ return __builtin_fmaxf(a, b); ++} ++ ++double ++_fmin(double a, double b) ++{ ++ return __builtin_fmin(a, b); ++} ++ ++float ++_fminf(float a, float b) ++{ ++ return __builtin_fminf(a, b); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Remove-redundant-sign-extension-instructio.patch
Added
@@ -0,0 +1,180 @@ +From fbe6421c5600a151dbae96d18db2fd31aca2fe7c Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 24 Aug 2023 16:44:56 +0800 +Subject: PATCH 051/124 LoongArch: Remove redundant sign extension + instructions caused by SLT instructions. + +Since the SLT instruction does not distinguish between 64-bit operations and 32-bit +operations under the 64-bit LoongArch architecture, if the operand of slt is SImode, +the sign extension of the operand needs to be displayed. + +But similar to the test case below, the sign extension is redundant: + + extern int src1, src2, src3; + + int + test (void) + { + int data1 = src1 + src2; + int data2 = src1 + src3; + return data1 > data2 ? data1 : data2; + } +Assembly code before optimization: + ... + add.w $r4,$r4,$r14 + add.w $r13,$r13,$r14 + slli.w $r12,$r4,0 + slli.w $r14,$r13,0 + slt $r12,$r12,$r14 + masknez $r4,$r4,$r12 + maskeqz $r12,$r13,$r12 + or $r4,$r4,$r12 + slli.w $r4,$r4,0 + ... + +After optimization: + ... + add.w $r12,$r12,$r14 + add.w $r13,$r13,$r14 + slt $r4,$r12,$r13 + masknez $r12,$r12,$r4 + maskeqz $r4,$r13,$r4 + or $r4,$r12,$r4 + ... + +Similar to this test example, the two operands of SLT are obtained by the +addition operation, and add.w implicitly sign-extends, so the two operands +of SLT do not require sign-extend. + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_expand_conditional_move): + Optimize the function implementation. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/slt-sign-extend.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 53 +++++++++++++++++-- + .../gcc.target/loongarch/slt-sign-extend.c | 14 +++++ + 2 files changed, 63 insertions(+), 4 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/slt-sign-extend.c + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index f14de5cce..caacfa8a3 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -4380,14 +4380,30 @@ loongarch_expand_conditional_move (rtx *operands) + enum rtx_code code = GET_CODE (operands1); + rtx op0 = XEXP (operands1, 0); + rtx op1 = XEXP (operands1, 1); ++ rtx op0_extend = op0; ++ rtx op1_extend = op1; ++ ++ /* Record whether operands2 and operands3 modes are promoted to word_mode. */ ++ bool promote_p = false; ++ machine_mode mode = GET_MODE (operands0); + + if (FLOAT_MODE_P (GET_MODE (op1))) + loongarch_emit_float_compare (&code, &op0, &op1); + else + { ++ if ((REGNO (op0) == REGNO (operands2) ++ || (REGNO (op1) == REGNO (operands3) && (op1 != const0_rtx))) ++ && (GET_MODE_SIZE (GET_MODE (op0)) < word_mode)) ++ { ++ mode = word_mode; ++ promote_p = true; ++ } ++ + loongarch_extend_comparands (code, &op0, &op1); + + op0 = force_reg (word_mode, op0); ++ op0_extend = op0; ++ op1_extend = force_reg (word_mode, op1); + + if (code == EQ || code == NE) + { +@@ -4414,23 +4430,52 @@ loongarch_expand_conditional_move (rtx *operands) + && register_operand (operands2, VOIDmode) + && register_operand (operands3, VOIDmode)) + { +- machine_mode mode = GET_MODE (operands0); ++ rtx op2 = operands2; ++ rtx op3 = operands3; ++ ++ if (promote_p) ++ { ++ if (REGNO (XEXP (operands1, 0)) == REGNO (operands2)) ++ op2 = op0_extend; ++ else ++ { ++ loongarch_extend_comparands (code, &op2, &const0_rtx); ++ op2 = force_reg (mode, op2); ++ } ++ ++ if (REGNO (XEXP (operands1, 1)) == REGNO (operands3)) ++ op3 = op1_extend; ++ else ++ { ++ loongarch_extend_comparands (code, &op3, &const0_rtx); ++ op3 = force_reg (mode, op3); ++ } ++ } ++ + rtx temp = gen_reg_rtx (mode); + rtx temp2 = gen_reg_rtx (mode); + + emit_insn (gen_rtx_SET (temp, + gen_rtx_IF_THEN_ELSE (mode, cond, +- operands2, const0_rtx))); ++ op2, const0_rtx))); + + /* Flip the test for the second operand. */ + cond = gen_rtx_fmt_ee ((code == EQ) ? NE : EQ, GET_MODE (op0), op0, op1); + + emit_insn (gen_rtx_SET (temp2, + gen_rtx_IF_THEN_ELSE (mode, cond, +- operands3, const0_rtx))); ++ op3, const0_rtx))); + + /* Merge the two results, at least one is guaranteed to be zero. */ +- emit_insn (gen_rtx_SET (operands0, gen_rtx_IOR (mode, temp, temp2))); ++ if (promote_p) ++ { ++ rtx temp3 = gen_reg_rtx (mode); ++ emit_insn (gen_rtx_SET (temp3, gen_rtx_IOR (mode, temp, temp2))); ++ temp3 = gen_lowpart (GET_MODE (operands0), temp3); ++ loongarch_emit_move (operands0, temp3); ++ } ++ else ++ emit_insn (gen_rtx_SET (operands0, gen_rtx_IOR (mode, temp, temp2))); + } + else + emit_insn (gen_rtx_SET (operands0, +diff --git a/gcc/testsuite/gcc.target/loongarch/slt-sign-extend.c b/gcc/testsuite/gcc.target/loongarch/slt-sign-extend.c +new file mode 100644 +index 000000000..ea6b28b7c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/slt-sign-extend.c +@@ -0,0 +1,14 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O2" } */ ++/* { dg-final { scan-assembler-not "slli.w" } } */ ++ ++extern int src1, src2, src3; ++ ++int ++test (void) ++{ ++ int data1 = src1 + src2; ++ int data2 = src1 + src3; ++ ++ return data1 > data2 ? data1 : data2; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Remove-the-definition-of-the-macro-LOGICAL.patch
Added
@@ -0,0 +1,36 @@ +From 297b8c5770ad85bf468526602e28aff8a66dc01a Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 13 Apr 2023 19:24:38 +0800 +Subject: PATCH 040/124 LoongArch: Remove the definition of the macro + LOGICAL_OP_NON_SHORT_CIRCUIT under the architecture and use the default + definition instead. + +In some cases, setting this macro as the default can reduce the number of conditional +branch instructions. + +gcc/ChangeLog: + + * config/loongarch/loongarch.h (LOGICAL_OP_NON_SHORT_CIRCUIT): Remove the macro + definition. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.h | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index 392597943..c6e37b1b4 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -836,7 +836,6 @@ typedef struct { + 1 is the default; other values are interpreted relative to that. */ + + #define BRANCH_COST(speed_p, predictable_p) loongarch_branch_cost +-#define LOGICAL_OP_NON_SHORT_CIRCUIT 0 + + /* Return the asm template for a conditional branch instruction. + OPCODE is the opcode's mnemonic and OPERANDS is the asm template for +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Rename-frint_-fmt-to-rint-mode-2.patch
Added
@@ -0,0 +1,65 @@ +From 7584716b03b13c06b8bb9956b9f49e0cfc29c6b3 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Sun, 6 Nov 2022 20:41:38 +0800 +Subject: PATCH 027/124 LoongArch: Rename frint_<fmt> to rint<mode>2 + +Use standard name so __builtin_rint{,f} can be expanded to one +instruction. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (frint_<fmt>): Rename to .. + (rint<mode>2): .. this. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/frint.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 4 ++-- + gcc/testsuite/gcc.target/loongarch/frint.c | 16 ++++++++++++++++ + 2 files changed, 18 insertions(+), 2 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/frint.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index bda34d0f3..a14ab14ac 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -2012,8 +2012,8 @@ + (set_attr "type" "move") + ) + +-;; Convert floating-point numbers to integers +-(define_insn "frint_<fmt>" ++;; Round floating-point numbers to integers ++(define_insn "rint<mode>2" + (set (match_operand:ANYF 0 "register_operand" "=f") + (unspec:ANYF (match_operand:ANYF 1 "register_operand" "f") + UNSPEC_FRINT)) +diff --git a/gcc/testsuite/gcc.target/loongarch/frint.c b/gcc/testsuite/gcc.target/loongarch/frint.c +new file mode 100644 +index 000000000..3ee6a8f97 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/frint.c +@@ -0,0 +1,16 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mdouble-float" } */ ++/* { dg-final { scan-assembler "frint\\.s" } } */ ++/* { dg-final { scan-assembler "frint\\.d" } } */ ++ ++double ++my_rint (double a) ++{ ++ return __builtin_rint (a); ++} ++ ++float ++my_rintf (float a) ++{ ++ return __builtin_rintf (a); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Set-default-alignment-for-functions-and-la.patch
Added
@@ -0,0 +1,113 @@ +From 129d96b9ab5a2445d0fc2c3f7b72baa0453bd93f Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 14 Jun 2023 08:24:05 +0800 +Subject: PATCH 047/124 LoongArch: Set default alignment for functions and + labels with -mtune + +The LA464 micro-architecture is sensitive to alignment of code. The +Loongson team has benchmarked various combinations of function, the +results 1 show that 16-byte label alignment together with 32-byte +function alignment gives best results in terms of SPEC score. + +Add a mtune-based table-driven mechanism to set the default of +-falign-{functions,labels}. As LA464 is the first (and the only for +now) uarch supported by GCC, the same setting is also used for +the "generic" -mtune=loongarch64. In the future we may set different +settings for LA{2,3,6}64 once we add the support for them. + +Bootstrapped and regtested on loongarch64-linux-gnu. Ok for trunk? + +gcc/ChangeLog: + + * config/loongarch/loongarch-tune.h (loongarch_align): New + struct. + * config/loongarch/loongarch-def.h (loongarch_cpu_align): New + array. + * config/loongarch/loongarch-def.c (loongarch_cpu_align): Define + the array. + * config/loongarch/loongarch.cc + (loongarch_option_override_internal): Set the value of + -falign-functions= if -falign-functions is enabled but no value + is given. Likewise for -falign-labels=. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-def.c | 12 ++++++++++++ + gcc/config/loongarch/loongarch-def.h | 1 + + gcc/config/loongarch/loongarch-tune.h | 8 ++++++++ + gcc/config/loongarch/loongarch.cc | 6 ++++++ + 4 files changed, 27 insertions(+) + +diff --git a/gcc/config/loongarch/loongarch-def.c b/gcc/config/loongarch/loongarch-def.c +index 80ab10a52..74d422ce0 100644 +--- a/gcc/config/loongarch/loongarch-def.c ++++ b/gcc/config/loongarch/loongarch-def.c +@@ -72,6 +72,18 @@ loongarch_cpu_cacheN_TUNE_TYPES = { + }, + }; + ++struct loongarch_align ++loongarch_cpu_alignN_TUNE_TYPES = { ++ CPU_LOONGARCH64 = { ++ .function = "32", ++ .label = "16", ++ }, ++ CPU_LA464 = { ++ .function = "32", ++ .label = "16", ++ }, ++}; ++ + /* The following properties cannot be looked up directly using "cpucfg". + So it is necessary to provide a default value for "unknown native" + tune targets (i.e. -mtune=native while PRID does not correspond to +diff --git a/gcc/config/loongarch/loongarch-def.h b/gcc/config/loongarch/loongarch-def.h +index b5985f070..eb87a79a5 100644 +--- a/gcc/config/loongarch/loongarch-def.h ++++ b/gcc/config/loongarch/loongarch-def.h +@@ -144,6 +144,7 @@ extern int loongarch_cpu_issue_rate; + extern int loongarch_cpu_multipass_dfa_lookahead; + + extern struct loongarch_cache loongarch_cpu_cache; ++extern struct loongarch_align loongarch_cpu_align; + extern struct loongarch_rtx_cost_data loongarch_cpu_rtx_cost_data; + + #ifdef __cplusplus +diff --git a/gcc/config/loongarch/loongarch-tune.h b/gcc/config/loongarch/loongarch-tune.h +index 8e3eb2947..d961963f0 100644 +--- a/gcc/config/loongarch/loongarch-tune.h ++++ b/gcc/config/loongarch/loongarch-tune.h +@@ -48,4 +48,12 @@ struct loongarch_cache { + int simultaneous_prefetches; /* number of parallel prefetch */ + }; + ++/* Alignment for functions and labels for best performance. For new uarchs ++ the value should be measured via benchmarking. See the documentation for ++ -falign-functions and -falign-labels in invoke.texi for the format. */ ++struct loongarch_align { ++ const char *function; /* default value for -falign-functions */ ++ const char *label; /* default value for -falign-labels */ ++}; ++ + #endif /* LOONGARCH_TUNE_H */ +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 4c0f393b6..f14de5cce 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -6246,6 +6246,12 @@ loongarch_option_override_internal (struct gcc_options *opts) + && !opts->x_optimize_size) + opts->x_flag_prefetch_loop_arrays = 1; + ++ if (opts->x_flag_align_functions && !opts->x_str_align_functions) ++ opts->x_str_align_functions = loongarch_cpu_alignLARCH_ACTUAL_TUNE.function; ++ ++ if (opts->x_flag_align_labels && !opts->x_str_align_labels) ++ opts->x_str_align_labels = loongarch_cpu_alignLARCH_ACTUAL_TUNE.label; ++ + if (TARGET_DIRECT_EXTERN_ACCESS && flag_shlib) + error ("%qs cannot be used for compiling a shared library", + "-mdirect-extern-access"); +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Slightly-simplify-loongarch_block_move_str.patch
Added
@@ -0,0 +1,37 @@ +From f4a0248c80fedff3a6841407ff95b732dfbb93a1 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Fri, 8 Sep 2023 00:29:57 +0800 +Subject: PATCH 073/124 LoongArch: Slightly simplify + loongarch_block_move_straight + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_block_move_straight): + Check precondition (delta must be a power of 2) and use + popcount_hwi instead of a homebrew loop. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 5 ++--- + 1 file changed, 2 insertions(+), 3 deletions(-) + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index baa5c2354..baa9831aa 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -5221,9 +5221,8 @@ loongarch_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length, + emit two ld.d/st.d pairs, one ld.w/st.w pair, and one ld.b/st.b + pair. For each load/store pair we use a dedicated register to keep + the pipeline as populated as possible. */ +- HOST_WIDE_INT num_reg = length / delta; +- for (delta_cur = delta / 2; delta_cur != 0; delta_cur /= 2) +- num_reg += !!(length & delta_cur); ++ gcc_assert (pow2p_hwi (delta)); ++ HOST_WIDE_INT num_reg = length / delta + popcount_hwi (length % delta); + + /* Allocate a buffer for the temporary registers. */ + regs = XALLOCAVEC (rtx, num_reg); +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Subdivision-symbol-type-add-SYMBOL_PCREL-s.patch
Added
@@ -0,0 +1,1234 @@ +From 68bb2a2d0b94b9bde3c22ff1dfe08abb6f036e7f Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 21 Jul 2022 10:32:51 +0800 +Subject: PATCH 003/124 LoongArch: Subdivision symbol type, add SYMBOL_PCREL + support. + +1. Remove cModel type support other than normal. +2. The method for calling global functions changed from 'la.global + jirl' to 'bl' + when complied add '-fplt'. + +gcc/ChangeLog: + + * config/loongarch/constraints.md (a): Delete the constraint. + (b): A constant call not local address. + (h): Delete the constraint. + (t): Delete the constraint. + * config/loongarch/loongarch-opts.cc (loongarch_config_target): + Remove cModel type support other than normal. + * config/loongarch/loongarch-protos.h (enum loongarch_symbol_type): + Add new symbol type 'SYMBOL_PCREL', 'SYMBOL_TLS_IE' and 'SYMBOL_TLS_LE'. + (loongarch_split_symbol): Delete useless function declarations. + (loongarch_split_symbol_type): Delete useless function declarations. + * config/loongarch/loongarch.cc (enum loongarch_address_type): + Delete unnecessary comment information. + (loongarch_symbol_binds_local_p): Modified the judgment order of label + and symbol. + (loongarch_classify_symbol): Return symbol type. If symbol is a label, + or symbol is a local symbol return SYMBOL_PCREL. If is a tls symbol, + return SYMBOL_TLS. If is a not local symbol return SYMBOL_GOT_DISP. + (loongarch_symbolic_constant_p): Add handling of 'SYMBOL_TLS_IE' + 'SYMBOL_TLS_LE' and 'SYMBOL_PCREL'. + (loongarch_symbol_insns): Add handling of 'SYMBOL_TLS_IE' 'SYMBOL_TLS_LE' + and 'SYMBOL_PCREL'. + (loongarch_address_insns): Sort code. + (loongarch_12bit_offset_address_p): Sort code. + (loongarch_14bit_shifted_offset_address_p): Sort code. + (loongarch_call_tls_get_addr): Sort code. + (loongarch_legitimize_tls_address): Sort code. + (loongarch_output_move): Remove schema support for cmodel other than normal. + (loongarch_memmodel_needs_release_fence): Sort code. + (loongarch_print_operand): Sort code. + * config/loongarch/loongarch.h (LARCH_U12BIT_OFFSET_P): + Rename to LARCH_12BIT_OFFSET_P. + (LARCH_12BIT_OFFSET_P): New macro. + * config/loongarch/loongarch.md: Reimplement the function call. Remove schema + support for cmodel other than normal. + * config/loongarch/predicates.md (is_const_call_weak_symbol): Delete this predicate. + (is_const_call_plt_symbol): Delete this predicate. + (is_const_call_global_noplt_symbol): Delete this predicate. + (is_const_call_no_local_symbol): New predicate, determines whether it is a local + symbol or label. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/func-call-1.c: New test. + * gcc.target/loongarch/func-call-2.c: New test. + * gcc.target/loongarch/func-call-3.c: New test. + * gcc.target/loongarch/func-call-4.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/constraints.md | 24 +- + gcc/config/loongarch/loongarch-opts.cc | 7 + + gcc/config/loongarch/loongarch-protos.h | 9 +- + gcc/config/loongarch/loongarch.cc | 256 +++++++--------- + gcc/config/loongarch/loongarch.h | 2 +- + gcc/config/loongarch/loongarch.md | 279 +++--------------- + gcc/config/loongarch/predicates.md | 40 ++- + .../gcc.target/loongarch/func-call-1.c | 32 ++ + .../gcc.target/loongarch/func-call-2.c | 32 ++ + .../gcc.target/loongarch/func-call-3.c | 32 ++ + .../gcc.target/loongarch/func-call-4.c | 32 ++ + 11 files changed, 312 insertions(+), 433 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-3.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-4.c + +diff --git a/gcc/config/loongarch/constraints.md b/gcc/config/loongarch/constraints.md +index d0bfddbd5..43cb7b5f0 100644 +--- a/gcc/config/loongarch/constraints.md ++++ b/gcc/config/loongarch/constraints.md +@@ -20,14 +20,14 @@ + + ;; Register constraints + +-;; "a" "A constant call global and noplt address." +-;; "b" <-----unused ++;; "a" <-----unused ++;; "b" "A constant call not local address." + ;; "c" "A constant call local address." + ;; "d" <-----unused + ;; "e" JIRL_REGS + ;; "f" FP_REGS + ;; "g" <-----unused +-;; "h" "A constant call plt address." ++;; "h" <-----unused + ;; "i" "Matches a general integer constant." (Global non-architectural) + ;; "j" SIBCALL_REGS + ;; "k" "A memory operand whose address is formed by a base register and +@@ -42,7 +42,7 @@ + ;; "q" CSR_REGS + ;; "r" GENERAL_REGS (Global non-architectural) + ;; "s" "Matches a symbolic integer constant." (Global non-architectural) +-;; "t" "A constant call weak address" ++;; "t" <-----unused + ;; "u" "A signed 52bit constant and low 32-bit is zero (for logic instructions)" + ;; "v" "A signed 64-bit constant and low 44-bit is zero (for logic instructions)." + ;; "w" "Matches any valid memory." +@@ -89,10 +89,10 @@ + ;; "<" "Matches a pre-dec or post-dec operand." (Global non-architectural) + ;; ">" "Matches a pre-inc or post-inc operand." (Global non-architectural) + +-(define_constraint "a" ++(define_constraint "b" + "@internal +- A constant call global and noplt address." +- (match_operand 0 "is_const_call_global_noplt_symbol")) ++ A constant call no local address." ++ (match_operand 0 "is_const_call_no_local_symbol")) + + (define_constraint "c" + "@internal +@@ -105,11 +105,6 @@ + (define_register_constraint "f" "TARGET_HARD_FLOAT ? FP_REGS : NO_REGS" + "A floating-point register (if available).") + +-(define_constraint "h" +- "@internal +- A constant call plt address." +- (match_operand 0 "is_const_call_plt_symbol")) +- + (define_register_constraint "j" "SIBCALL_REGS" + "@internal") + +@@ -134,11 +129,6 @@ + (define_register_constraint "q" "CSR_REGS" + "A general-purpose register except for $r0 and $r1 for lcsr.") + +-(define_constraint "t" +- "@internal +- A constant call weak address." +- (match_operand 0 "is_const_call_weak_symbol")) +- + (define_constraint "u" + "A signed 52bit constant and low 32-bit is zero (for logic instructions)." + (and (match_code "const_int") +diff --git a/gcc/config/loongarch/loongarch-opts.cc b/gcc/config/loongarch/loongarch-opts.cc +index eb9c2a52f..fc477bfd4 100644 +--- a/gcc/config/loongarch/loongarch-opts.cc ++++ b/gcc/config/loongarch/loongarch-opts.cc +@@ -376,6 +376,13 @@ fallback: + + /* 5. Target code model */ + t.cmodel = constrained.cmodel ? opt_cmodel : CMODEL_NORMAL; ++ if (t.cmodel != CMODEL_NORMAL) ++ { ++ warning (0, "%qs is not supported, now cmodel is set to 'normal'.", ++ loongarch_cmodel_stringst.cmodel); ++ t.cmodel = CMODEL_NORMAL; ++ } ++ + + /* Cleanup and return. */ + obstack_free (&msg_obstack, NULL); +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 2287fd376..080766250 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -27,9 +27,13 @@ along with GCC; see the file COPYING3. If not see + SYMBOL_GOT_DISP + The symbol's value will be loaded directly from the GOT. + ++ SYMBOL_PCREL ++ The symbol's value will be loaded directly from data section. ++ + SYMBOL_TLS + A thread-local symbol. + ++ SYMBOL_TLS_IE + SYMBOL_TLSGD + SYMBOL_TLSLDM + UNSPEC wrappers around SYMBOL_TLS, corresponding to the +@@ -37,7 +41,10 @@ along with GCC; see the file COPYING3. If not see + */ + enum loongarch_symbol_type { + SYMBOL_GOT_DISP, ++ SYMBOL_PCREL, + SYMBOL_TLS, ++ SYMBOL_TLS_IE, ++ SYMBOL_TLS_LE, + SYMBOL_TLSGD, + SYMBOL_TLSLDM, + }; +@@ -61,7 +68,6 @@ extern int loongarch_idiv_insns (machine_mode); + #ifdef RTX_CODE + extern void loongarch_emit_binary (enum rtx_code, rtx, rtx, rtx); + #endif +-extern bool loongarch_split_symbol (rtx, rtx, machine_mode, rtx *); + extern rtx loongarch_unspec_address (rtx, enum loongarch_symbol_type); + extern rtx loongarch_strip_unspec_address (rtx); + extern void loongarch_move_integer (rtx, rtx, unsigned HOST_WIDE_INT); +@@ -154,7 +160,6 @@ extern rtx loongarch_expand_thread_pointer (rtx); + extern bool loongarch_eh_uses (unsigned int); + extern bool loongarch_epilogue_uses (unsigned int); + extern bool loongarch_load_store_bonding_p (rtx *, machine_mode, bool); +-extern bool loongarch_split_symbol_type (enum loongarch_symbol_type); + + typedef rtx (*mulsidi3_gen_fn) (rtx, rtx, rtx); + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 750d53bbe..2e2f16e72 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -114,19 +114,7 @@ enum loongarch_address_type + }; + + +-/* Information about an address described by loongarch_address_type. +- +- ADDRESS_CONST_INT +- No fields are used. +- +- ADDRESS_REG +- REG is the base register and OFFSET is the constant offset. +- +- ADDRESS_REG_REG +- A base register indexed by (optionally scaled) register. +- +- ADDRESS_SYMBOLIC +- SYMBOL_TYPE is the type of symbol that the address references. */ ++/* Information about an address described by loongarch_address_type. */ + struct loongarch_address_info + { + enum loongarch_address_type type; +@@ -1617,11 +1605,12 @@ loongarch_weak_symbol_p (const_rtx x) + bool + loongarch_symbol_binds_local_p (const_rtx x) + { +- if (LABEL_REF_P (x)) ++ if (SYMBOL_REF_P (x)) ++ return (SYMBOL_REF_DECL (x) ++ ? targetm.binds_local_p (SYMBOL_REF_DECL (x)) ++ : SYMBOL_REF_LOCAL_P (x)); ++ else + return false; +- +- return (SYMBOL_REF_DECL (x) ? targetm.binds_local_p (SYMBOL_REF_DECL (x)) +- : SYMBOL_REF_LOCAL_P (x)); + } + + /* Return true if rtx constants of mode MODE should be put into a small +@@ -1640,17 +1629,16 @@ static enum loongarch_symbol_type + loongarch_classify_symbol (const_rtx x) + { + if (LABEL_REF_P (x)) +- return SYMBOL_GOT_DISP; +- +- gcc_assert (SYMBOL_REF_P (x)); ++ return SYMBOL_PCREL; + + if (SYMBOL_REF_TLS_MODEL (x)) + return SYMBOL_TLS; + +- if (SYMBOL_REF_P (x)) ++ if (SYMBOL_REF_P (x) ++ && !loongarch_symbol_binds_local_p (x)) + return SYMBOL_GOT_DISP; + +- return SYMBOL_GOT_DISP; ++ return SYMBOL_PCREL; + } + + /* Return true if X is a symbolic constant. If it is, +@@ -1683,9 +1671,15 @@ loongarch_symbolic_constant_p (rtx x, enum loongarch_symbol_type *symbol_type) + relocations. */ + switch (*symbol_type) + { +- case SYMBOL_GOT_DISP: ++ case SYMBOL_TLS_IE: ++ case SYMBOL_TLS_LE: + case SYMBOL_TLSGD: + case SYMBOL_TLSLDM: ++ case SYMBOL_PCREL: ++ /* GAS rejects offsets outside the range -2^31, 2^31-1. */ ++ return sext_hwi (INTVAL (offset), 32) == INTVAL (offset); ++ ++ case SYMBOL_GOT_DISP: + case SYMBOL_TLS: + return false; + } +@@ -1707,9 +1701,14 @@ loongarch_symbol_insns (enum loongarch_symbol_type type, machine_mode mode) + + return 3; + ++ case SYMBOL_PCREL: ++ case SYMBOL_TLS_IE: ++ case SYMBOL_TLS_LE: ++ return 2; ++ + case SYMBOL_TLSGD: + case SYMBOL_TLSLDM: +- return 1; ++ return 3; + + case SYMBOL_TLS: + /* We don't treat a bare TLS symbol as a constant. */ +@@ -1937,11 +1936,7 @@ loongarch_address_insns (rtx x, machine_mode mode, bool might_split_p) + switch (addr.type) + { + case ADDRESS_REG: +- return factor; +- + case ADDRESS_REG_REG: +- return factor; +- + case ADDRESS_CONST_INT: + return factor; + +@@ -1983,7 +1978,7 @@ loongarch_12bit_offset_address_p (rtx x, machine_mode mode) + return (loongarch_classify_address (&addr, x, mode, false) + && addr.type == ADDRESS_REG + && CONST_INT_P (addr.offset) +- && LARCH_U12BIT_OFFSET_P (INTVAL (addr.offset))); ++ && LARCH_12BIT_OFFSET_P (INTVAL (addr.offset))); + } + + /* Return true if X is a legitimate address with a 14-bit offset shifted 2. +@@ -2001,6 +1996,9 @@ loongarch_14bit_shifted_offset_address_p (rtx x, machine_mode mode) + && LARCH_SHIFT_2_OFFSET_P (INTVAL (addr.offset))); + } + ++/* Return true if X is a legitimate address with base and index. ++ MODE is the mode of the value being accessed. */ ++ + bool + loongarch_base_index_address_p (rtx x, machine_mode mode) + { +@@ -2310,7 +2308,7 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + + /* Generate the code to access LOC, a thread-local SYMBOL_REF, and return + its address. The return value will be both a valid address and a valid +- SET_SRC (either a REG or a LO_SUM). */ ++ SET_SRC. */ + + static rtx + loongarch_legitimize_tls_address (rtx loc) +@@ -2336,7 +2334,7 @@ loongarch_legitimize_tls_address (rtx loc) + break; + + case TLS_MODEL_INITIAL_EXEC: +- /* la.tls.ie; tp-relative add */ ++ /* la.tls.ie; tp-relative add. */ + tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM); + tmp = gen_reg_rtx (Pmode); + emit_insn (loongarch_got_load_tls_ie (tmp, loc)); +@@ -2345,7 +2343,7 @@ loongarch_legitimize_tls_address (rtx loc) + break; + + case TLS_MODEL_LOCAL_EXEC: +- /* la.tls.le; tp-relative add */ ++ /* la.tls.le; tp-relative add. */ + tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM); + tmp = gen_reg_rtx (Pmode); + emit_insn (loongarch_got_load_tls_le (tmp, loc)); +@@ -3371,6 +3369,7 @@ loongarch_output_move (rtx dest, rtx src) + case 2: + return "st.h\t%z1,%0"; + case 4: ++ /* Matching address type with a 12bit offset. */ + if (const_arith_operand (offset, Pmode)) + return "st.w\t%z1,%0"; + else +@@ -3409,6 +3408,7 @@ loongarch_output_move (rtx dest, rtx src) + case 2: + return "ld.hu\t%0,%1"; + case 4: ++ /* Matching address type with a 12bit offset. */ + if (const_arith_operand (offset, Pmode)) + return "ld.w\t%0,%1"; + else +@@ -3436,56 +3436,16 @@ loongarch_output_move (rtx dest, rtx src) + else + gcc_unreachable (); + } ++ } + +- if (symbolic_operand (src, VOIDmode)) +- { +- if ((TARGET_CMODEL_TINY && (!loongarch_global_symbol_p (src) +- || loongarch_symbol_binds_local_p (src))) +- || (TARGET_CMODEL_TINY_STATIC && !loongarch_weak_symbol_p (src))) +- { +- /* The symbol must be aligned to 4 byte. */ +- unsigned int align; +- +- if (LABEL_REF_P (src)) +- align = 32 /* Whatever. */; +- else if (CONSTANT_POOL_ADDRESS_P (src)) +- align = GET_MODE_ALIGNMENT (get_pool_mode (src)); +- else if (TREE_CONSTANT_POOL_ADDRESS_P (src)) +- { +- tree exp = SYMBOL_REF_DECL (src); +- align = TYPE_ALIGN (TREE_TYPE (exp)); +- align = loongarch_constant_alignment (exp, align); +- } +- else if (SYMBOL_REF_DECL (src)) +- align = DECL_ALIGN (SYMBOL_REF_DECL (src)); +- else if (SYMBOL_REF_HAS_BLOCK_INFO_P (src) +- && SYMBOL_REF_BLOCK (src) != NULL) +- align = SYMBOL_REF_BLOCK (src)->alignment; +- else +- align = BITS_PER_UNIT; +- +- if (align % (4 * 8) == 0) +- return "pcaddi\t%0,%%pcrel(%1)>>2"; +- } +- if (TARGET_CMODEL_TINY +- || TARGET_CMODEL_TINY_STATIC +- || TARGET_CMODEL_NORMAL +- || TARGET_CMODEL_LARGE) +- { +- if (!loongarch_global_symbol_p (src) +- || loongarch_symbol_binds_local_p (src)) +- return "la.local\t%0,%1"; +- else +- return "la.global\t%0,%1"; +- } +- if (TARGET_CMODEL_EXTREME) +- { +- sorry ("Normal symbol loading not implemented in extreme mode."); +- gcc_unreachable (); +- } +- +- } ++ if (dest_code == REG && symbolic_operand (src, VOIDmode)) ++ { ++ if (loongarch_classify_symbol (src) == SYMBOL_PCREL) ++ return "la.local\t%0,%1"; ++ else ++ return "la.global\t%0,%1"; + } ++ + if (src_code == REG && FP_REG_P (REGNO (src))) + { + if (dest_code == REG && FP_REG_P (REGNO (dest))) +@@ -3503,6 +3463,7 @@ loongarch_output_move (rtx dest, rtx src) + return dbl_p ? "fst.d\t%1,%0" : "fst.s\t%1,%0"; + } + } ++ + if (dest_code == REG && FP_REG_P (REGNO (dest))) + { + if (src_code == MEM) +@@ -3517,6 +3478,7 @@ loongarch_output_move (rtx dest, rtx src) + return dbl_p ? "fld.d\t%0,%1" : "fld.s\t%0,%1"; + } + } ++ + gcc_unreachable (); + } + +@@ -4347,27 +4309,27 @@ loongarch_memmodel_needs_release_fence (enum memmodel model) + + /* Implement TARGET_PRINT_OPERAND. The LoongArch-specific operand codes are: + +- 'X' Print CONST_INT OP in hexadecimal format. +- 'x' Print the low 16 bits of CONST_INT OP in hexadecimal format. ++ 'A' Print a _DB suffix if the memory model requires a release. ++ 'b' Print the address of a memory operand, without offset. ++ 'C' Print the integer branch condition for comparison OP. + 'd' Print CONST_INT OP in decimal. ++ 'F' Print the FPU branch condition for comparison OP. ++ 'G' Print a DBAR insn if the memory model requires a release. ++ 'i' Print i if the operand is not a register. + 'm' Print one less than CONST_INT OP in decimal. +- 'y' Print exact log2 of CONST_INT OP in decimal. +- 'C' Print the integer branch condition for comparison OP. + 'N' Print the inverse of the integer branch condition for comparison OP. +- 'F' Print the FPU branch condition for comparison OP. +- 'W' Print the inverse of the FPU branch condition for comparison OP. + 'T' Print 'f' for (eq:CC ...), 't' for (ne:CC ...), + 'z' for (eq:?I ...), 'n' for (ne:?I ...). + 't' Like 'T', but with the EQ/NE cases reversed +- 'Y' Print loongarch_fp_conditionsINTVAL (OP) +- 'Z' Print OP and a comma for 8CC, otherwise print nothing. +- 'z' Print $0 if OP is zero, otherwise print OP normally. +- 'b' Print the address of a memory operand, without offset. + 'V' Print exact log2 of CONST_INT OP element 0 of a replicated + CONST_VECTOR in decimal. +- 'A' Print a _DB suffix if the memory model requires a release. +- 'G' Print a DBAR insn if the memory model requires a release. +- 'i' Print i if the operand is not a register. */ ++ 'W' Print the inverse of the FPU branch condition for comparison OP. ++ 'X' Print CONST_INT OP in hexadecimal format. ++ 'x' Print the low 16 bits of CONST_INT OP in hexadecimal format. ++ 'Y' Print loongarch_fp_conditionsINTVAL (OP) ++ 'y' Print exact log2 of CONST_INT OP in decimal. ++ 'Z' Print OP and a comma for 8CC, otherwise print nothing. ++ 'z' Print $0 if OP is zero, otherwise print OP normally. */ + + static void + loongarch_print_operand (FILE *file, rtx op, int letter) +@@ -4385,18 +4347,13 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + + switch (letter) + { +- case 'X': +- if (CONST_INT_P (op)) +- fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (op)); +- else +- output_operand_lossage ("invalid use of '%%%c'", letter); ++ case 'A': ++ if (loongarch_memmodel_needs_rel_acq_fence ((enum memmodel) INTVAL (op))) ++ fputs ("_db", file); + break; + +- case 'x': +- if (CONST_INT_P (op)) +- fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (op) & 0xffff); +- else +- output_operand_lossage ("invalid use of '%%%c'", letter); ++ case 'C': ++ loongarch_print_int_branch_condition (file, code, letter); + break; + + case 'd': +@@ -4406,6 +4363,20 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + output_operand_lossage ("invalid use of '%%%c'", letter); + break; + ++ case 'F': ++ loongarch_print_float_branch_condition (file, code, letter); ++ break; ++ ++ case 'G': ++ if (loongarch_memmodel_needs_release_fence ((enum memmodel) INTVAL (op))) ++ fputs ("dbar\t0", file); ++ break; ++ ++ case 'i': ++ if (code != REG) ++ fputs ("i", file); ++ break; ++ + case 'm': + if (CONST_INT_P (op)) + fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (op) - 1); +@@ -4413,17 +4384,17 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + output_operand_lossage ("invalid use of '%%%c'", letter); + break; + +- case 'y': +- if (CONST_INT_P (op)) +- { +- int val = exact_log2 (INTVAL (op)); +- if (val != -1) +- fprintf (file, "%d", val); +- else +- output_operand_lossage ("invalid use of '%%%c'", letter); +- } +- else +- output_operand_lossage ("invalid use of '%%%c'", letter); ++ case 'N': ++ loongarch_print_int_branch_condition (file, reverse_condition (code), ++ letter); ++ break; ++ ++ case 't': ++ case 'T': ++ { ++ int truth = (code == NE) == (letter == 'T'); ++ fputc ("zfnt"truth * 2 + FCC_REG_P (REGNO (XEXP (op, 0))), file); ++ } + break; + + case 'V': +@@ -4441,30 +4412,36 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + output_operand_lossage ("invalid use of '%%%c'", letter); + break; + +- case 'C': +- loongarch_print_int_branch_condition (file, code, letter); +- break; +- +- case 'N': +- loongarch_print_int_branch_condition (file, reverse_condition (code), +- letter); ++ case 'W': ++ loongarch_print_float_branch_condition (file, reverse_condition (code), ++ letter); + break; + +- case 'F': +- loongarch_print_float_branch_condition (file, code, letter); ++ case 'x': ++ if (CONST_INT_P (op)) ++ fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (op) & 0xffff); ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); + break; + +- case 'W': +- loongarch_print_float_branch_condition (file, reverse_condition (code), +- letter); ++ case 'X': ++ if (CONST_INT_P (op)) ++ fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (op)); ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); + break; + +- case 'T': +- case 't': +- { +- int truth = (code == NE) == (letter == 'T'); +- fputc ("zfnt"truth * 2 + FCC_REG_P (REGNO (XEXP (op, 0))), file); +- } ++ case 'y': ++ if (CONST_INT_P (op)) ++ { ++ int val = exact_log2 (INTVAL (op)); ++ if (val != -1) ++ fprintf (file, "%d", val); ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); ++ } ++ else ++ output_operand_lossage ("invalid use of '%%%c'", letter); + break; + + case 'Y': +@@ -4481,21 +4458,6 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + fputc (',', file); + break; + +- case 'A': +- if (loongarch_memmodel_needs_rel_acq_fence ((enum memmodel) INTVAL (op))) +- fputs ("_db", file); +- break; +- +- case 'G': +- if (loongarch_memmodel_needs_release_fence ((enum memmodel) INTVAL (op))) +- fputs ("dbar\t0", file); +- break; +- +- case 'i': +- if (code != REG) +- fputs ("i", file); +- break; +- + default: + switch (code) + { +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index 714401f2d..12f209047 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -617,7 +617,7 @@ enum reg_class + #define LU12I_INT(X) LU12I_OPERAND (INTVAL (X)) + #define LU32I_INT(X) LU32I_OPERAND (INTVAL (X)) + #define LU52I_INT(X) LU52I_OPERAND (INTVAL (X)) +-#define LARCH_U12BIT_OFFSET_P(OFFSET) (IN_RANGE (OFFSET, -2048, 2047)) ++#define LARCH_12BIT_OFFSET_P(OFFSET) (IN_RANGE (OFFSET, -2048, 2047)) + #define LARCH_9BIT_OFFSET_P(OFFSET) (IN_RANGE (OFFSET, -256, 255)) + #define LARCH_16BIT_OFFSET_P(OFFSET) (IN_RANGE (OFFSET, -32768, 32767)) + #define LARCH_SHIFT_2_OFFSET_P(OFFSET) (((OFFSET) & 0x3) == 0) +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 5c0445dd8..376879fbc 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -2844,48 +2844,14 @@ + }) + + (define_insn "sibcall_internal" +- (call (mem:SI (match_operand 0 "call_insn_operand" "j,c,a,t,h")) ++ (call (mem:SI (match_operand 0 "call_insn_operand" "j,c,b")) + (match_operand 1 "" "")) + "SIBLING_CALL_P (insn)" +-{ +- switch (which_alternative) +- { +- case 0: +- return "jr\t%0"; +- case 1: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r12,(%%pcrel(%0+0x20000))>>18\n\t" +- "jirl\t$r0,$r12,%%pcrel(%0+4)-(%%pcrel(%0+4+0x20000)>>18<<18)"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.local\t$r12,$r13,%0\n\tjr\t$r12"; +- else +- return "b\t%0"; +- case 2: +- if (TARGET_CMODEL_TINY_STATIC) +- return "b\t%0"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r12,$r13,%0\n\tjr\t$r12"; +- else +- return "la.global\t$r12,%0\n\tjr\t$r12"; +- case 3: +- if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r12,$r13,%0\n\tjr\t$r12"; +- else +- return "la.global\t$r12,%0\n\tjr\t$r12"; +- case 4: +- if (TARGET_CMODEL_NORMAL || TARGET_CMODEL_TINY) +- return "b\t%%plt(%0)"; +- else if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r12,(%%plt(%0)+0x20000)>>18\n\t" +- "jirl\t$r0,$r12,%%plt(%0)+4-((%%plt(%0)+(4+0x20000))>>18<<18)"; +- else +- /* Cmodel extreme and tiny static not support plt. */ +- gcc_unreachable (); +- default: +- gcc_unreachable (); +- } +-} +- (set_attr "jirl" "indirect,direct,direct,direct,direct")) ++ "@ ++ jr\t%0 ++ b\t%0 ++ b\t%%plt(%0)" ++ (set_attr "jirl" "indirect,direct,direct")) + + (define_expand "sibcall_value" + (parallel (set (match_operand 0 "") +@@ -2920,96 +2886,28 @@ + + (define_insn "sibcall_value_internal" + (set (match_operand 0 "register_operand" "") +- (call (mem:SI (match_operand 1 "call_insn_operand" "j,c,a,t,h")) ++ (call (mem:SI (match_operand 1 "call_insn_operand" "j,c,b")) + (match_operand 2 "" ""))) + "SIBLING_CALL_P (insn)" +-{ +- switch (which_alternative) +- { +- case 0: +- return "jr\t%1"; +- case 1: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r12,%%pcrel(%1+0x20000)>>18\n\t" +- "jirl\t$r0,$r12,%%pcrel(%1+4)-((%%pcrel(%1+4+0x20000))>>18<<18)"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.local\t$r12,$r13,%1\n\tjr\t$r12"; +- else +- return "b\t%1"; +- case 2: +- if (TARGET_CMODEL_TINY_STATIC) +- return "b\t%1"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r12,$r13,%1\n\tjr\t$r12"; +- else +- return "la.global\t$r12,%1\n\tjr\t$r12"; +- case 3: +- if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r12,$r13,%1\n\tjr\t$r12"; +- else +- return "la.global\t$r12,%1\n\tjr\t$r12"; +- case 4: +- if (TARGET_CMODEL_NORMAL || TARGET_CMODEL_TINY) +- return " b\t%%plt(%1)"; +- else if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r12,(%%plt(%1)+0x20000)>>18\n\t" +- "jirl\t$r0,$r12,%%plt(%1)+4-((%%plt(%1)+(4+0x20000))>>18<<18)"; +- else +- /* Cmodel extreme and tiny static not support plt. */ +- gcc_unreachable (); +- default: +- gcc_unreachable (); +- } +-} +- (set_attr "jirl" "indirect,direct,direct,direct,direct")) ++ "@ ++ jr\t%1 ++ b\t%1 ++ b\t%%plt(%1)" ++ (set_attr "jirl" "indirect,direct,direct")) + + (define_insn "sibcall_value_multiple_internal" + (set (match_operand 0 "register_operand" "") +- (call (mem:SI (match_operand 1 "call_insn_operand" "j,c,a,t,h")) ++ (call (mem:SI (match_operand 1 "call_insn_operand" "j,c,b")) + (match_operand 2 "" ""))) + (set (match_operand 3 "register_operand" "") + (call (mem:SI (match_dup 1)) + (match_dup 2))) + "SIBLING_CALL_P (insn)" +-{ +- switch (which_alternative) +- { +- case 0: +- return "jr\t%1"; +- case 1: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r12,%%pcrel(%1+0x20000)>>18\n\t" +- "jirl\t$r0,$r12,%%pcrel(%1+4)-(%%pcrel(%1+4+0x20000)>>18<<18)"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.local\t$r12,$r13,%1\n\tjr\t$r12"; +- else +- return "b\t%1"; +- case 2: +- if (TARGET_CMODEL_TINY_STATIC) +- return "b\t%1"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r12,$r13,%1\n\tjr\t$r12"; +- else +- return "la.global\t$r12,%1\n\tjr\t$r12"; +- case 3: +- if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r12,$r13,%1\n\tjr\t$r12"; +- else +- return "la.global\t$r12,%1\n\tjr\t$r12"; +- case 4: +- if (TARGET_CMODEL_NORMAL || TARGET_CMODEL_TINY) +- return "b\t%%plt(%1)"; +- else if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r12,(%%plt(%1)+0x20000)>>18\n\t" +- "jirl\t$r0,$r12,%%plt(%1)+4-((%%plt(%1)+(4+0x20000))>>18<<18)"; +- else +- /* Cmodel extreme and tiny static not support plt. */ +- gcc_unreachable (); +- default: +- gcc_unreachable (); +- } +-} +- (set_attr "jirl" "indirect,direct,direct,direct,direct")) ++ "@ ++ jr\t%1 ++ b\t%1 ++ b\t%%plt(%1)" ++ (set_attr "jirl" "indirect,direct,direct")) + + (define_expand "call" + (parallel (call (match_operand 0 "") +@@ -3025,50 +2923,15 @@ + }) + + (define_insn "call_internal" +- (call (mem:SI (match_operand 0 "call_insn_operand" "e,c,a,t,h")) ++ (call (mem:SI (match_operand 0 "call_insn_operand" "e,c,b")) + (match_operand 1 "" "")) + (clobber (reg:SI RETURN_ADDR_REGNUM)) + "" +-{ +- switch (which_alternative) +- { +- case 0: +- return "jirl\t$r1,%0,0"; +- case 1: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r1,%%pcrel(%0+0x20000)>>18\n\t" +- "jirl\t$r1,$r1,%%pcrel(%0+4)-(%%pcrel(%0+4+0x20000)>>18<<18)"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.local\t$r1,$r12,%0\n\tjirl\t$r1,$r1,0"; +- else +- return "bl\t%0"; +- case 2: +- if (TARGET_CMODEL_TINY_STATIC) +- return "bl\t%0"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r1,$r12,%0\n\tjirl\t$r1,$r1,0"; +- else +- return "la.global\t$r1,%0\n\tjirl\t$r1,$r1,0"; +- case 3: +- if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r1,$r12,%0\n\tjirl\t$r1,$r1,0"; +- else +- return "la.global\t$r1,%0\n\tjirl\t$r1,$r1,0"; +- case 4: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r1,(%%plt(%0)+0x20000)>>18\n\t" +- "jirl\t$r1,$r1,%%plt(%0)+4-((%%plt(%0)+(4+0x20000))>>18<<18)"; +- else if (TARGET_CMODEL_NORMAL || TARGET_CMODEL_TINY) +- return "bl\t%%plt(%0)"; +- else +- /* Cmodel extreme and tiny static not support plt. */ +- gcc_unreachable (); +- default: +- gcc_unreachable (); +- } +-} +- (set_attr "jirl" "indirect,direct,direct,direct,direct") +- (set_attr "insn_count" "1,2,3,3,2")) ++ "@ ++ jirl\t$r1,%0,0 ++ bl\t%0 ++ bl\t%%plt(%0)" ++ (set_attr "jirl" "indirect,direct,direct")) + + (define_expand "call_value" + (parallel (set (match_operand 0 "") +@@ -3101,100 +2964,30 @@ + + (define_insn "call_value_internal" + (set (match_operand 0 "register_operand" "") +- (call (mem:SI (match_operand 1 "call_insn_operand" "e,c,a,t,h")) ++ (call (mem:SI (match_operand 1 "call_insn_operand" "e,c,b")) + (match_operand 2 "" ""))) + (clobber (reg:SI RETURN_ADDR_REGNUM)) + "" +-{ +- switch (which_alternative) +- { +- case 0: +- return "jirl\t$r1,%1,0"; +- case 1: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r1,%%pcrel(%1+0x20000)>>18\n\t" +- "jirl\t$r1,$r1,%%pcrel(%1+4)-(%%pcrel(%1+4+0x20000)>>18<<18)"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.local\t$r1,$r12,%1\n\tjirl\t$r1,$r1,0"; +- else +- return "bl\t%1"; +- case 2: +- if (TARGET_CMODEL_TINY_STATIC) +- return "bl\t%1"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r1,$r12,%1\n\tjirl\t$r1,$r1,0"; +- else +- return "la.global\t$r1,%1\n\tjirl\t$r1,$r1,0"; +- case 3: +- if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r1,$r12,%1\n\tjirl\t$r1,$r1,0"; +- else +- return "la.global\t$r1,%1\n\tjirl\t$r1,$r1,0"; +- case 4: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r1,(%%plt(%1)+0x20000)>>18\n\t" +- "jirl\t$r1,$r1,%%plt(%1)+4-((%%plt(%1)+(4+0x20000))>>18<<18)"; +- else if (TARGET_CMODEL_NORMAL || TARGET_CMODEL_TINY) +- return "bl\t%%plt(%1)"; +- else +- /* Cmodel extreme and tiny static not support plt. */ +- gcc_unreachable (); +- default: +- gcc_unreachable (); +- } +-} +- (set_attr "jirl" "indirect,direct,direct,direct,direct") +- (set_attr "insn_count" "1,2,3,3,2")) ++ "@ ++ jirl\t$r1,%1,0 ++ bl\t%1 ++ bl\t%%plt(%1)" ++ (set_attr "jirl" "indirect,direct,direct")) + + (define_insn "call_value_multiple_internal" + (set (match_operand 0 "register_operand" "") +- (call (mem:SI (match_operand 1 "call_insn_operand" "e,c,a,t,h")) ++ (call (mem:SI (match_operand 1 "call_insn_operand" "e,c,b")) + (match_operand 2 "" ""))) + (set (match_operand 3 "register_operand" "") + (call (mem:SI (match_dup 1)) + (match_dup 2))) + (clobber (reg:SI RETURN_ADDR_REGNUM)) + "" +-{ +- switch (which_alternative) +- { +- case 0: +- return "jirl\t$r1,%1,0"; +- case 1: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r1,%%pcrel(%1+0x20000)>>18\n\t" +- "jirl\t$r1,$r1,%%pcrel(%1+4)-(%%pcrel(%1+4+0x20000)>>18<<18)"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.local\t$r1,$r12,%1\n\tjirl\t$r1,$r1,0"; +- else +- return "bl\t%1"; +- case 2: +- if (TARGET_CMODEL_TINY_STATIC) +- return "bl\t%1"; +- else if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r1,$r12,%1\n\tjirl\t$r1,$r1,0 "; +- else +- return "la.global\t$r1,%1\n\tjirl\t$r1,$r1,0"; +- case 3: +- if (TARGET_CMODEL_EXTREME) +- return "la.global\t$r1,$r12,%1\n\tjirl\t$r1,$r1,0"; +- else +- return "la.global\t$r1,%1\n\tjirl\t$r1,$r1,0"; +- case 4: +- if (TARGET_CMODEL_LARGE) +- return "pcaddu18i\t$r1,(%%plt(%1)+0x20000)>>18\n\t" +- "jirl\t$r1,$r1,%%plt(%1)+4-((%%plt(%1)+(4+0x20000))>>18<<18)"; +- else if (TARGET_CMODEL_NORMAL || TARGET_CMODEL_TINY) +- return "bl\t%%plt(%1)"; +- else +- /* Cmodel extreme and tiny static not support plt. */ +- gcc_unreachable (); +- default: +- gcc_unreachable (); +- } +-} +- (set_attr "jirl" "indirect,direct,direct,direct,direct") +- (set_attr "insn_count" "1,2,3,3,2")) ++ "@ ++ jirl\t$r1,%1,0 ++ bl\t%1 ++ bl\t%%plt(%1)" ++ (set_attr "jirl" "indirect,direct,direct")) + + + ;; Call subroutine returning any type. +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index edd74d478..2243ef71c 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -111,20 +111,25 @@ + (match_code "const,symbol_ref,label_ref") + { + enum loongarch_symbol_type symbol_type; ++ loongarch_symbolic_constant_p (op, &symbol_type); + +- if (!loongarch_symbolic_constant_p (op, &symbol_type)) ++ rtx offset, x = op; ++ split_const (x, &x, &offset); ++ ++ if (offset != const0_rtx) + return false; + + switch (symbol_type) + { +- case SYMBOL_GOT_DISP: +- /* Without explicit relocs, there is no special syntax for +- loading the address of a call destination into a register. +- Using "la.global JIRL_REGS,foo; jirl JIRL_REGS" would prevent the lazy +- binding of "foo", so keep the address of global symbols with the jirl +- macro. */ ++ case SYMBOL_PCREL: + return 1; + ++ case SYMBOL_GOT_DISP: ++ if (!flag_plt) ++ return false; ++ else ++ return 1; ++ + default: + return false; + } +@@ -140,22 +145,11 @@ + (match_test "loongarch_symbol_binds_local_p (op) != 0")) + (match_test "CONSTANT_P (op)"))) + +-(define_predicate "is_const_call_weak_symbol" +- (and (match_operand 0 "const_call_insn_operand") +- (not (match_operand 0 "is_const_call_local_symbol")) +- (match_test "loongarch_weak_symbol_p (op) != 0") +- (match_test "CONSTANT_P (op)"))) +- +-(define_predicate "is_const_call_plt_symbol" +- (and (match_operand 0 "const_call_insn_operand") +- (match_test "flag_plt != 0") +- (match_test "loongarch_global_symbol_noweak_p (op) != 0") +- (match_test "CONSTANT_P (op)"))) +- +-(define_predicate "is_const_call_global_noplt_symbol" ++(define_predicate "is_const_call_no_local_symbol" + (and (match_operand 0 "const_call_insn_operand") +- (match_test "flag_plt == 0") +- (match_test "loongarch_global_symbol_noweak_p (op) != 0") ++ (ior (match_test "loongarch_global_symbol_p (op) != 0") ++ (match_test "loongarch_symbol_binds_local_p (op) == 0") ++ (match_test "loongarch_weak_symbol_p (op) != 0")) + (match_test "CONSTANT_P (op)"))) + + ;; A legitimate CONST_INT operand that takes more than one instruction +@@ -219,7 +213,7 @@ + case CONST: + case SYMBOL_REF: + case LABEL_REF: +- return (loongarch_symbolic_constant_p (op, &symbol_type)); ++ return loongarch_symbolic_constant_p (op, &symbol_type); + default: + return true; + } +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-1.c b/gcc/testsuite/gcc.target/loongarch/func-call-1.c +new file mode 100644 +index 000000000..b0482761a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-1.c +@@ -0,0 +1,32 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fplt" } */ ++/* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ ++/* { dg-final { scan-assembler "test1:.*bl\t%plt\\(f\\)\n" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-2.c b/gcc/testsuite/gcc.target/loongarch/func-call-2.c +new file mode 100644 +index 000000000..f5e061c29 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-2.c +@@ -0,0 +1,32 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt" } */ ++/* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ ++/* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-3.c b/gcc/testsuite/gcc.target/loongarch/func-call-3.c +new file mode 100644 +index 000000000..75082c574 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-3.c +@@ -0,0 +1,32 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt" } */ ++/* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*la\.global\t.*f\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-4.c b/gcc/testsuite/gcc.target/loongarch/func-call-4.c +new file mode 100644 +index 000000000..e8a839549 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-4.c +@@ -0,0 +1,32 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt" } */ ++/* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++extern void g (void); ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Support-split-symbol.patch
Added
@@ -0,0 +1,1238 @@ +From 078261cabef370e7f3201980d03bd54a049290e9 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Thu, 21 Jul 2022 11:04:08 +0800 +Subject: PATCH 004/124 LoongArch: Support split symbol. + +Add compilation option '-mexplicit-relocs', and if enable '-mexplicit-relocs' +the symbolic address load instruction 'la.*' will be split into two instructions. +This compilation option enabled by default. + +gcc/ChangeLog: + + * common/config/loongarch/loongarch-common.cc: + Enable '-fsection-anchors' when O1 and more advanced optimization. + * config/loongarch/genopts/loongarch.opt.in: Add new option + '-mexplicit-relocs', and enable by default. + * config/loongarch/loongarch-protos.h (loongarch_split_move_insn_p): + Delete function declaration. + (loongarch_split_move_insn): Delete function declaration. + (loongarch_split_symbol_type): Add function declaration. + * config/loongarch/loongarch.cc (enum loongarch_address_type): + Add new address type 'ADDRESS_LO_SUM'. + (loongarch_classify_symbolic_expression): New function definitions. + Classify the base of symbolic expression X, given that X appears in + context CONTEXT. + (loongarch_symbol_insns): Add a judgment condition TARGET_EXPLICIT_RELOCS. + (loongarch_split_symbol_type): New function definitions. + Determines whether the symbol load should be split into two instructions. + (loongarch_valid_lo_sum_p): New function definitions. + Return true if a LO_SUM can address a value of mode MODE when the LO_SUM + symbol has type SYMBOL_TYPE. + (loongarch_classify_address): Add handling of 'LO_SUM'. + (loongarch_address_insns): Add handling of 'ADDRESS_LO_SUM'. + (loongarch_signed_immediate_p): Sort code. + (loongarch_12bit_offset_address_p): Return true if address type is ADDRESS_LO_SUM. + (loongarch_const_insns): Add handling of 'HIGH'. + (loongarch_split_move_insn_p): Add the static attribute to the function. + (loongarch_emit_set): New function definitions. + (loongarch_call_tls_get_addr): Add symbol handling when defining TARGET_EXPLICIT_RELOCS. + (loongarch_legitimize_tls_address): Add symbol handling when defining the + TARGET_EXPLICIT_RELOCS macro. + (loongarch_split_symbol): New function definitions. Split symbol. + (loongarch_legitimize_address): Add codes see if the address can split into a high part + and a LO_SUM. + (loongarch_legitimize_const_move): Add codes split moves of symbolic constants into + high and low. + (loongarch_split_move_insn): Delete function definitions. + (loongarch_output_move): Add support for HIGH and LO_SUM. + (loongarch_print_operand_reloc): New function definitions. + Print symbolic operand OP, which is part of a HIGH or LO_SUM in context CONTEXT. + (loongarch_memmodel_needs_release_fence): Sort code. + (loongarch_print_operand): Rearrange alphabetical order and add H and L to support HIGH + and LOW output. + (loongarch_print_operand_address): Add handling of 'ADDRESS_LO_SUM'. + (TARGET_MIN_ANCHOR_OFFSET): Define macro to -IMM_REACH/2. + (TARGET_MAX_ANCHOR_OFFSET): Define macro to IMM_REACH/2-1. + * config/loongarch/loongarch.md (movti): Delete the template. + (*movti): Delete the template. + (movtf): Delete the template. + (*movtf): Delete the template. + (*low<mode>): New template of normal symbol low address. + (@tls_low<mode>): New template of tls symbol low address. + (@ld_from_got<mode>): New template load address from got table. + (@ori_l_lo12<mode>): New template. + * config/loongarch/loongarch.opt: Update from loongarch.opt.in. + * config/loongarch/predicates.md: Add support for symbol_type HIGH. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/func-call-1.c: Add build option '-mno-explicit-relocs'. + * gcc.target/loongarch/func-call-2.c: Add build option '-mno-explicit-relocs'. + * gcc.target/loongarch/func-call-3.c: Add build option '-mno-explicit-relocs'. + * gcc.target/loongarch/func-call-4.c: Add build option '-mno-explicit-relocs'. + * gcc.target/loongarch/func-call-5.c: New test. + * gcc.target/loongarch/func-call-6.c: New test. + * gcc.target/loongarch/func-call-7.c: New test. + * gcc.target/loongarch/func-call-8.c: New test. + * gcc.target/loongarch/relocs-symbol-noaddend.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + .../config/loongarch/loongarch-common.cc | 1 + + gcc/config/loongarch/genopts/loongarch.opt.in | 4 + + gcc/config/loongarch/loongarch-protos.h | 3 +- + gcc/config/loongarch/loongarch.cc | 412 ++++++++++++++++-- + gcc/config/loongarch/loongarch.md | 122 +++--- + gcc/config/loongarch/loongarch.opt | 4 + + gcc/config/loongarch/predicates.md | 20 +- + .../gcc.target/loongarch/func-call-1.c | 2 +- + .../gcc.target/loongarch/func-call-2.c | 2 +- + .../gcc.target/loongarch/func-call-3.c | 2 +- + .../gcc.target/loongarch/func-call-4.c | 2 +- + .../gcc.target/loongarch/func-call-5.c | 33 ++ + .../gcc.target/loongarch/func-call-6.c | 33 ++ + .../gcc.target/loongarch/func-call-7.c | 34 ++ + .../gcc.target/loongarch/func-call-8.c | 33 ++ + .../loongarch/relocs-symbol-noaddend.c | 23 + + 16 files changed, 614 insertions(+), 116 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-5.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-6.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-7.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/func-call-8.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c + +diff --git a/gcc/common/config/loongarch/loongarch-common.cc b/gcc/common/config/loongarch/loongarch-common.cc +index ed3730fce..f8b4660fa 100644 +--- a/gcc/common/config/loongarch/loongarch-common.cc ++++ b/gcc/common/config/loongarch/loongarch-common.cc +@@ -34,6 +34,7 @@ along with GCC; see the file COPYING3. If not see + static const struct default_options loongarch_option_optimization_table = + { + { OPT_LEVELS_ALL, OPT_fasynchronous_unwind_tables, NULL, 1 }, ++ { OPT_LEVELS_1_PLUS, OPT_fsection_anchors, NULL, 1 }, + { OPT_LEVELS_NONE, 0, NULL, 0 } + }; + +diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in +index 61e7d72a0..6f3950093 100644 +--- a/gcc/config/loongarch/genopts/loongarch.opt.in ++++ b/gcc/config/loongarch/genopts/loongarch.opt.in +@@ -154,6 +154,10 @@ mmax-inline-memcpy-size= + Target Joined RejectNegative UInteger Var(loongarch_max_inline_memcpy_size) Init(1024) + -mmax-inline-memcpy-size=SIZE Set the max size of memcpy to inline, default is 1024. + ++mexplicit-relocs ++Target Var(TARGET_EXPLICIT_RELOCS) Init(1) ++Use %reloc() assembly operators. ++ + ; The code model option names for -mcmodel. + Enum + Name(cmodel) Type(int) +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 080766250..cadaad751 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -77,8 +77,6 @@ extern rtx loongarch_legitimize_call_address (rtx); + extern rtx loongarch_subword (rtx, bool); + extern bool loongarch_split_move_p (rtx, rtx); + extern void loongarch_split_move (rtx, rtx, rtx); +-extern bool loongarch_split_move_insn_p (rtx, rtx); +-extern void loongarch_split_move_insn (rtx, rtx, rtx); + extern const char *loongarch_output_move (rtx, rtx); + extern bool loongarch_cfun_has_cprestore_slot_p (void); + #ifdef RTX_CODE +@@ -160,6 +158,7 @@ extern rtx loongarch_expand_thread_pointer (rtx); + extern bool loongarch_eh_uses (unsigned int); + extern bool loongarch_epilogue_uses (unsigned int); + extern bool loongarch_load_store_bonding_p (rtx *, machine_mode, bool); ++extern bool loongarch_split_symbol_type (enum loongarch_symbol_type); + + typedef rtx (*mulsidi3_gen_fn) (rtx, rtx, rtx); + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 2e2f16e72..1b5af2c7d 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -100,6 +100,10 @@ along with GCC; see the file COPYING3. If not see + ADDRESS_REG_REG + A base register indexed by (optionally scaled) register. + ++ ADDRESS_LO_SUM ++ A LO_SUM rtx. The first operand is a valid base register and the second ++ operand is a symbolic address. ++ + ADDRESS_CONST_INT + A signed 16-bit constant address. + +@@ -109,6 +113,7 @@ enum loongarch_address_type + { + ADDRESS_REG, + ADDRESS_REG_REG, ++ ADDRESS_LO_SUM, + ADDRESS_CONST_INT, + ADDRESS_SYMBOLIC + }; +@@ -1641,6 +1646,21 @@ loongarch_classify_symbol (const_rtx x) + return SYMBOL_PCREL; + } + ++/* Classify the base of symbolic expression X, given that X appears in ++ context CONTEXT. */ ++ ++static enum loongarch_symbol_type ++loongarch_classify_symbolic_expression (rtx x) ++{ ++ rtx offset; ++ ++ split_const (x, &x, &offset); ++ if (UNSPEC_ADDRESS_P (x)) ++ return UNSPEC_ADDRESS_TYPE (x); ++ ++ return loongarch_classify_symbol (x); ++} ++ + /* Return true if X is a symbolic constant. If it is, + store the type of the symbol in *SYMBOL_TYPE. */ + +@@ -1696,7 +1716,7 @@ loongarch_symbol_insns (enum loongarch_symbol_type type, machine_mode mode) + case SYMBOL_GOT_DISP: + /* The constant will have to be loaded from the GOT before it + is used in an address. */ +- if (mode != MAX_MACHINE_MODE) ++ if (!TARGET_EXPLICIT_RELOCS && mode != MAX_MACHINE_MODE) + return 0; + + return 3; +@@ -1814,6 +1834,84 @@ loongarch_valid_offset_p (rtx x, machine_mode mode) + return true; + } + ++/* Should a symbol of type SYMBOL_TYPE should be split in two? */ ++ ++bool ++loongarch_split_symbol_type (enum loongarch_symbol_type symbol_type) ++{ ++ switch (symbol_type) ++ { ++ case SYMBOL_PCREL: ++ case SYMBOL_GOT_DISP: ++ case SYMBOL_TLS_IE: ++ case SYMBOL_TLS_LE: ++ case SYMBOL_TLSGD: ++ case SYMBOL_TLSLDM: ++ return true; ++ ++ case SYMBOL_TLS: ++ return false; ++ ++ default: ++ gcc_unreachable (); ++ } ++} ++ ++/* Return true if a LO_SUM can address a value of mode MODE when the ++ LO_SUM symbol has type SYMBOL_TYPE. */ ++ ++static bool ++loongarch_valid_lo_sum_p (enum loongarch_symbol_type symbol_type, ++ machine_mode mode, rtx x) ++{ ++ int align, size; ++ ++ /* Check that symbols of type SYMBOL_TYPE can be used to access values ++ of mode MODE. */ ++ if (loongarch_symbol_insns (symbol_type, mode) == 0) ++ return false; ++ ++ /* Check that there is a known low-part relocation. */ ++ if (!loongarch_split_symbol_type (symbol_type)) ++ return false; ++ ++ /* We can't tell size or alignment when we have BLKmode, so try extracing a ++ decl from the symbol if possible. */ ++ if (mode == BLKmode) ++ { ++ rtx offset; ++ ++ /* Extract the symbol from the LO_SUM operand, if any. */ ++ split_const (x, &x, &offset); ++ ++ /* Might be a CODE_LABEL. We can compute align but not size for that, ++ so don't bother trying to handle it. */ ++ if (!SYMBOL_REF_P (x)) ++ return false; ++ ++ /* Use worst case assumptions if we don't have a SYMBOL_REF_DECL. */ ++ align = (SYMBOL_REF_DECL (x) ++ ? DECL_ALIGN (SYMBOL_REF_DECL (x)) ++ : 1); ++ size = (SYMBOL_REF_DECL (x) && DECL_SIZE (SYMBOL_REF_DECL (x)) ++ ? tree_to_uhwi (DECL_SIZE (SYMBOL_REF_DECL (x))) ++ : 2*BITS_PER_WORD); ++ } ++ else ++ { ++ align = GET_MODE_ALIGNMENT (mode); ++ size = GET_MODE_BITSIZE (mode); ++ } ++ ++ /* We may need to split multiword moves, so make sure that each word ++ can be accessed without inducing a carry. */ ++ if (size > BITS_PER_WORD ++ && (!TARGET_STRICT_ALIGN || size > align)) ++ return false; ++ ++ return true; ++} ++ + static bool + loongarch_valid_index_p (struct loongarch_address_info *info, rtx x, + machine_mode mode, bool strict_p) +@@ -1880,6 +1978,26 @@ loongarch_classify_address (struct loongarch_address_info *info, rtx x, + info->offset = XEXP (x, 1); + return (loongarch_valid_base_register_p (info->reg, mode, strict_p) + && loongarch_valid_offset_p (info->offset, mode)); ++ ++ case LO_SUM: ++ info->type = ADDRESS_LO_SUM; ++ info->reg = XEXP (x, 0); ++ info->offset = XEXP (x, 1); ++ /* We have to trust the creator of the LO_SUM to do something vaguely ++ sane. Target-independent code that creates a LO_SUM should also ++ create and verify the matching HIGH. Target-independent code that ++ adds an offset to a LO_SUM must prove that the offset will not ++ induce a carry. Failure to do either of these things would be ++ a bug, and we are not required to check for it here. The MIPS ++ backend itself should only create LO_SUMs for valid symbolic ++ constants, with the high part being either a HIGH or a copy ++ of _gp. */ ++ info->symbol_type ++ = loongarch_classify_symbolic_expression (info->offset); ++ return (loongarch_valid_base_register_p (info->reg, mode, strict_p) ++ && loongarch_valid_lo_sum_p (info->symbol_type, mode, ++ info->offset)); ++ + default: + return false; + } +@@ -1940,6 +2058,9 @@ loongarch_address_insns (rtx x, machine_mode mode, bool might_split_p) + case ADDRESS_CONST_INT: + return factor; + ++ case ADDRESS_LO_SUM: ++ return factor + 1; ++ + case ADDRESS_SYMBOLIC: + return factor * loongarch_symbol_insns (addr.symbol_type, mode); + } +@@ -1967,7 +2088,8 @@ loongarch_signed_immediate_p (unsigned HOST_WIDE_INT x, int bits, + return loongarch_unsigned_immediate_p (x, bits, shift); + } + +-/* Return true if X is a legitimate address with a 12-bit offset. ++/* Return true if X is a legitimate address with a 12-bit offset ++ or addr.type is ADDRESS_LO_SUM. + MODE is the mode of the value being accessed. */ + + bool +@@ -1976,9 +2098,10 @@ loongarch_12bit_offset_address_p (rtx x, machine_mode mode) + struct loongarch_address_info addr; + + return (loongarch_classify_address (&addr, x, mode, false) +- && addr.type == ADDRESS_REG +- && CONST_INT_P (addr.offset) +- && LARCH_12BIT_OFFSET_P (INTVAL (addr.offset))); ++ && ((addr.type == ADDRESS_REG ++ && CONST_INT_P (addr.offset) ++ && LARCH_12BIT_OFFSET_P (INTVAL (addr.offset))) ++ || addr.type == ADDRESS_LO_SUM)); + } + + /* Return true if X is a legitimate address with a 14-bit offset shifted 2. +@@ -2020,6 +2143,14 @@ loongarch_const_insns (rtx x) + + switch (GET_CODE (x)) + { ++ case HIGH: ++ if (!loongarch_symbolic_constant_p (XEXP (x, 0), &symbol_type) ++ || !loongarch_split_symbol_type (symbol_type)) ++ return 0; ++ ++ /* This is simply a PCALAU12I. */ ++ return 1; ++ + case CONST_INT: + return loongarch_integer_cost (INTVAL (x)); + +@@ -2080,6 +2211,8 @@ loongarch_split_const_insns (rtx x) + return low + high; + } + ++static bool loongarch_split_move_insn_p (rtx dest, rtx src); ++ + /* Return the number of instructions needed to implement INSN, + given that it loads from or stores to MEM. */ + +@@ -2197,6 +2330,15 @@ loongarch_unspec_address (rtx address, enum loongarch_symbol_type symbol_type) + return loongarch_unspec_address_offset (base, offset, symbol_type); + } + ++/* Emit an instruction of the form (set TARGET SRC). */ ++ ++static rtx ++loongarch_emit_set (rtx target, rtx src) ++{ ++ emit_insn (gen_rtx_SET (target, src)); ++ return target; ++} ++ + /* If OP is an UNSPEC address, return the address to which it refers, + otherwise return OP itself. */ + +@@ -2278,6 +2420,7 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + { + rtx loc, a0; + rtx_insn *insn; ++ rtx tmp = gen_reg_rtx (Pmode); + + a0 = gen_rtx_REG (Pmode, GP_ARG_FIRST); + +@@ -2288,12 +2431,22 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + + start_sequence (); + +- if (type == SYMBOL_TLSLDM) +- emit_insn (loongarch_got_load_tls_ld (a0, loc)); +- else if (type == SYMBOL_TLSGD) +- emit_insn (loongarch_got_load_tls_gd (a0, loc)); ++ if (TARGET_EXPLICIT_RELOCS) ++ { ++ /* Split tls symbol to high and low. */ ++ rtx high = gen_rtx_HIGH (Pmode, copy_rtx (loc)); ++ high = loongarch_force_temporary (tmp, high); ++ emit_insn (gen_tls_low (Pmode, a0, high, loc)); ++ } + else +- gcc_unreachable (); ++ { ++ if (type == SYMBOL_TLSLDM) ++ emit_insn (loongarch_got_load_tls_ld (a0, loc)); ++ else if (type == SYMBOL_TLSGD) ++ emit_insn (loongarch_got_load_tls_gd (a0, loc)); ++ else ++ gcc_unreachable (); ++ } + + insn = emit_call_insn (gen_call_value_internal (v0, loongarch_tls_symbol, + const0_rtx)); +@@ -2308,12 +2461,12 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + + /* Generate the code to access LOC, a thread-local SYMBOL_REF, and return + its address. The return value will be both a valid address and a valid +- SET_SRC. */ ++ SET_SRC (either a REG or a LO_SUM). */ + + static rtx + loongarch_legitimize_tls_address (rtx loc) + { +- rtx dest, tp, tmp; ++ rtx dest, tp, tmp, tmp1, tmp2, tmp3; + enum tls_model model = SYMBOL_REF_TLS_MODEL (loc); + rtx_insn *insn; + +@@ -2334,21 +2487,45 @@ loongarch_legitimize_tls_address (rtx loc) + break; + + case TLS_MODEL_INITIAL_EXEC: +- /* la.tls.ie; tp-relative add. */ +- tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM); +- tmp = gen_reg_rtx (Pmode); +- emit_insn (loongarch_got_load_tls_ie (tmp, loc)); +- dest = gen_reg_rtx (Pmode); +- emit_insn (gen_add3_insn (dest, tmp, tp)); ++ { ++ /* la.tls.ie; tp-relative add. */ ++ tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM); ++ tmp1 = gen_reg_rtx (Pmode); ++ dest = gen_reg_rtx (Pmode); ++ if (TARGET_EXPLICIT_RELOCS) ++ { ++ tmp2 = loongarch_unspec_address (loc, SYMBOL_TLS_IE); ++ tmp3 = gen_reg_rtx (Pmode); ++ rtx high = gen_rtx_HIGH (Pmode, copy_rtx (tmp2)); ++ high = loongarch_force_temporary (tmp3, high); ++ emit_insn (gen_ld_from_got (Pmode, tmp1, high, tmp2)); ++ } ++ else ++ emit_insn (loongarch_got_load_tls_ie (tmp1, loc)); ++ emit_insn (gen_add3_insn (dest, tmp1, tp)); ++ } + break; + + case TLS_MODEL_LOCAL_EXEC: +- /* la.tls.le; tp-relative add. */ +- tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM); +- tmp = gen_reg_rtx (Pmode); +- emit_insn (loongarch_got_load_tls_le (tmp, loc)); +- dest = gen_reg_rtx (Pmode); +- emit_insn (gen_add3_insn (dest, tmp, tp)); ++ { ++ /* la.tls.le; tp-relative add. */ ++ tp = gen_rtx_REG (Pmode, THREAD_POINTER_REGNUM); ++ tmp1 = gen_reg_rtx (Pmode); ++ dest = gen_reg_rtx (Pmode); ++ ++ if (TARGET_EXPLICIT_RELOCS) ++ { ++ tmp2 = loongarch_unspec_address (loc, SYMBOL_TLS_LE); ++ tmp3 = gen_reg_rtx (Pmode); ++ rtx high = gen_rtx_HIGH (Pmode, copy_rtx (tmp2)); ++ high = loongarch_force_temporary (tmp3, high); ++ emit_insn (gen_ori_l_lo12 (Pmode, tmp1, high, tmp2)); ++ } ++ else ++ emit_insn (loongarch_got_load_tls_le (tmp1, loc)); ++ emit_insn (gen_add3_insn (dest, tmp1, tp)); ++ ++ } + break; + + default: +@@ -2397,6 +2574,68 @@ loongarch_force_address (rtx x, machine_mode mode) + return x; + } + ++/* If MODE is MAX_MACHINE_MODE, ADDR appears as a move operand, otherwise ++ it appears in a MEM of that mode. Return true if ADDR is a legitimate ++ constant in that context and can be split into high and low parts. ++ If so, and if LOW_OUT is nonnull, emit the high part and store the ++ low part in *LOW_OUT. Leave *LOW_OUT unchanged otherwise. ++ ++ Return false if build with '-mno-explicit-relocs'. ++ ++ TEMP is as for loongarch_force_temporary and is used to load the high ++ part into a register. ++ ++ When MODE is MAX_MACHINE_MODE, the low part is guaranteed to be ++ a legitimize SET_SRC for an .md pattern, otherwise the low part ++ is guaranteed to be a legitimate address for mode MODE. */ ++ ++bool ++loongarch_split_symbol (rtx temp, rtx addr, machine_mode mode, rtx *low_out) ++{ ++ enum loongarch_symbol_type symbol_type; ++ rtx high; ++ ++ /* If build with '-mno-explicit-relocs', don't split symbol. */ ++ if (!TARGET_EXPLICIT_RELOCS) ++ return false; ++ ++ if ((GET_CODE (addr) == HIGH && mode == MAX_MACHINE_MODE) ++ || !loongarch_symbolic_constant_p (addr, &symbol_type) ++ || loongarch_symbol_insns (symbol_type, mode) == 0 ++ || !loongarch_split_symbol_type (symbol_type)) ++ return false; ++ ++ if (temp == NULL) ++ temp = gen_reg_rtx (Pmode); ++ ++ /* Get the 12-31 bits of the address. */ ++ high = gen_rtx_HIGH (Pmode, copy_rtx (addr)); ++ high = loongarch_force_temporary (temp, high); ++ ++ if (low_out) ++ switch (symbol_type) ++ { ++ case SYMBOL_PCREL: ++ *low_out = gen_rtx_LO_SUM (Pmode, high, addr); ++ break; ++ ++ case SYMBOL_GOT_DISP: ++ /* SYMBOL_GOT_DISP symbols are loaded from the GOT. */ ++ { ++ rtx low = gen_rtx_LO_SUM (Pmode, high, addr); ++ rtx mem = gen_rtx_MEM (Pmode, low); ++ *low_out = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, mem), ++ UNSPEC_LOAD_FROM_GOT); ++ break; ++ } ++ ++ default: ++ gcc_unreachable (); ++ } ++ ++ return true; ++} ++ + /* This function is used to implement LEGITIMIZE_ADDRESS. If X can + be legitimized in a way that the generic machinery might not expect, + return a new address, otherwise return NULL. MODE is the mode of +@@ -2412,6 +2651,10 @@ loongarch_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, + if (loongarch_tls_symbol_p (x)) + return loongarch_legitimize_tls_address (x); + ++ /* See if the address can split into a high part and a LO_SUM. */ ++ if (loongarch_split_symbol (NULL, x, mode, &addr)) ++ return loongarch_force_address (addr, mode); ++ + /* Handle BASE + OFFSET using loongarch_add_offset. */ + loongarch_split_plus (x, &base, &offset); + if (offset != 0) +@@ -2499,6 +2742,13 @@ loongarch_legitimize_const_move (machine_mode mode, rtx dest, rtx src) + return; + } + ++ /* Split moves of symbolic constants into high and low. */ ++ if (loongarch_split_symbol (dest, src, MAX_MACHINE_MODE, &src)) ++ { ++ loongarch_emit_set (dest, src); ++ return; ++ } ++ + /* Generate the appropriate access sequences for TLS symbols. */ + if (loongarch_tls_symbol_p (src)) + { +@@ -3241,21 +3491,12 @@ loongarch_split_move (rtx dest, rtx src, rtx insn_) + + /* Return true if a move from SRC to DEST in INSN should be split. */ + +-bool ++static bool + loongarch_split_move_insn_p (rtx dest, rtx src) + { + return loongarch_split_move_p (dest, src); + } + +-/* Split a move from SRC to DEST in INSN, given that +- loongarch_split_move_insn_p holds. */ +- +-void +-loongarch_split_move_insn (rtx dest, rtx src, rtx insn) +-{ +- loongarch_split_move (dest, src, insn); +-} +- + /* Implement TARGET_CONSTANT_ALIGNMENT. */ + + static HOST_WIDE_INT +@@ -3369,13 +3610,16 @@ loongarch_output_move (rtx dest, rtx src) + case 2: + return "st.h\t%z1,%0"; + case 4: +- /* Matching address type with a 12bit offset. */ +- if (const_arith_operand (offset, Pmode)) ++ /* Matching address type with a 12bit offset and ++ ADDRESS_LO_SUM. */ ++ if (const_arith_operand (offset, Pmode) ++ || GET_CODE (offset) == LO_SUM) + return "st.w\t%z1,%0"; + else + return "stptr.w\t%z1,%0"; + case 8: +- if (const_arith_operand (offset, Pmode)) ++ if (const_arith_operand (offset, Pmode) ++ || GET_CODE (offset) == LO_SUM) + return "st.d\t%z1,%0"; + else + return "stptr.d\t%z1,%0"; +@@ -3408,13 +3652,16 @@ loongarch_output_move (rtx dest, rtx src) + case 2: + return "ld.hu\t%0,%1"; + case 4: +- /* Matching address type with a 12bit offset. */ +- if (const_arith_operand (offset, Pmode)) ++ /* Matching address type with a 12bit offset and ++ ADDRESS_LO_SUM. */ ++ if (const_arith_operand (offset, Pmode) ++ || GET_CODE (offset) == LO_SUM) + return "ld.w\t%0,%1"; + else + return "ldptr.w\t%0,%1"; + case 8: +- if (const_arith_operand (offset, Pmode)) ++ if (const_arith_operand (offset, Pmode) ++ || GET_CODE (offset) == LO_SUM) + return "ld.d\t%0,%1"; + else + return "ldptr.d\t%0,%1"; +@@ -3423,6 +3670,21 @@ loongarch_output_move (rtx dest, rtx src) + } + } + ++ if (src_code == HIGH) ++ { ++ rtx offset, x; ++ split_const (XEXP (src, 0), &x, &offset); ++ enum loongarch_symbol_type type = SYMBOL_PCREL; ++ ++ if (UNSPEC_ADDRESS_P (x)) ++ type = UNSPEC_ADDRESS_TYPE (x); ++ ++ if (type == SYMBOL_TLS_LE) ++ return "lu12i.w\t%0,%h1"; ++ else ++ return "pcalau12i\t%0,%h1"; ++ } ++ + if (src_code == CONST_INT) + { + if (LU12I_INT (src)) +@@ -3438,7 +3700,8 @@ loongarch_output_move (rtx dest, rtx src) + } + } + +- if (dest_code == REG && symbolic_operand (src, VOIDmode)) ++ if (!TARGET_EXPLICIT_RELOCS ++ && dest_code == REG && symbolic_operand (src, VOIDmode)) + { + if (loongarch_classify_symbol (src) == SYMBOL_PCREL) + return "la.local\t%0,%1"; +@@ -4307,6 +4570,49 @@ loongarch_memmodel_needs_release_fence (enum memmodel model) + } + } + ++/* Print symbolic operand OP, which is part of a HIGH or LO_SUM ++ in context CONTEXT. HI_RELOC indicates a high-part reloc. */ ++ ++static void ++loongarch_print_operand_reloc (FILE *file, rtx op, bool hi_reloc) ++{ ++ const char *reloc; ++ ++ switch (loongarch_classify_symbolic_expression (op)) ++ { ++ case SYMBOL_PCREL: ++ reloc = hi_reloc ? "%pc_hi20" : "%pc_lo12"; ++ break; ++ ++ case SYMBOL_GOT_DISP: ++ reloc = hi_reloc ? "%got_pc_hi20" : "%got_pc_lo12"; ++ break; ++ ++ case SYMBOL_TLS_IE: ++ reloc = hi_reloc ? "%ie_pc_hi20" : "%ie_pc_lo12"; ++ break; ++ ++ case SYMBOL_TLS_LE: ++ reloc = hi_reloc ? "%le_hi20" : "%le_lo12"; ++ break; ++ ++ case SYMBOL_TLSGD: ++ reloc = hi_reloc ? "%gd_pc_hi20" : "%got_pc_lo12"; ++ break; ++ ++ case SYMBOL_TLSLDM: ++ reloc = hi_reloc ? "%ld_pc_hi20" : "%got_pc_lo12"; ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ ++ fprintf (file, "%s(", reloc); ++ output_addr_const (file, loongarch_strip_unspec_address (op)); ++ fputc (')', file); ++} ++ + /* Implement TARGET_PRINT_OPERAND. The LoongArch-specific operand codes are: + + 'A' Print a _DB suffix if the memory model requires a release. +@@ -4315,7 +4621,10 @@ loongarch_memmodel_needs_release_fence (enum memmodel model) + 'd' Print CONST_INT OP in decimal. + 'F' Print the FPU branch condition for comparison OP. + 'G' Print a DBAR insn if the memory model requires a release. ++ 'H' Print address 52-61bit relocation associated with OP. ++ 'h' Print the high-part relocation associated with OP. + 'i' Print i if the operand is not a register. ++ 'L' Print the low-part relocation associated with OP. + 'm' Print one less than CONST_INT OP in decimal. + 'N' Print the inverse of the integer branch condition for comparison OP. + 'T' Print 'f' for (eq:CC ...), 't' for (ne:CC ...), +@@ -4372,11 +4681,21 @@ loongarch_print_operand (FILE *file, rtx op, int letter) + fputs ("dbar\t0", file); + break; + ++ case 'h': ++ if (code == HIGH) ++ op = XEXP (op, 0); ++ loongarch_print_operand_reloc (file, op, true /* hi_reloc */); ++ break; ++ + case 'i': + if (code != REG) + fputs ("i", file); + break; + ++ case 'L': ++ loongarch_print_operand_reloc (file, op, false /* lo_reloc */); ++ break; ++ + case 'm': + if (CONST_INT_P (op)) + fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (op) - 1); +@@ -4517,6 +4836,11 @@ loongarch_print_operand_address (FILE *file, machine_mode /* mode */, rtx x) + reg_namesREGNO (addr.offset)); + return; + ++ case ADDRESS_LO_SUM: ++ fprintf (file, "%s,", reg_namesREGNO (addr.reg)); ++ loongarch_print_operand_reloc (file, addr.offset, false /* hi_reloc */); ++ return; ++ + case ADDRESS_CONST_INT: + fprintf (file, "%s,", reg_namesGP_REG_FIRST); + output_addr_const (file, x); +@@ -5891,6 +6215,12 @@ loongarch_starting_frame_offset (void) + #undef TARGET_TRAMPOLINE_INIT + #define TARGET_TRAMPOLINE_INIT loongarch_trampoline_init + ++#undef TARGET_MIN_ANCHOR_OFFSET ++#define TARGET_MIN_ANCHOR_OFFSET (-IMM_REACH/2) ++ ++#undef TARGET_MAX_ANCHOR_OFFSET ++#define TARGET_MAX_ANCHOR_OFFSET (IMM_REACH/2-1) ++ + #undef TARGET_ATOMIC_ASSIGN_EXPAND_FENV + #define TARGET_ATOMIC_ASSIGN_EXPAND_FENV loongarch_atomic_assign_expand_fenv + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 376879fbc..6b6df22a5 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -57,6 +57,10 @@ + ;; CRC + UNSPEC_CRC + UNSPEC_CRCC ++ ++ UNSPEC_LOAD_FROM_GOT ++ UNSPEC_ORI_L_LO12 ++ UNSPEC_TLS_LOW + ) + + (define_c_enum "unspecv" +@@ -1743,73 +1747,6 @@ + (set_attr "move_type" "move,load,store") + (set_attr "mode" "DF")) + +- +-;; 128-bit integer moves +- +-(define_expand "movti" +- (set (match_operand:TI 0) +- (match_operand:TI 1)) +- "TARGET_64BIT" +-{ +- if (loongarch_legitimize_move (TImode, operands0, operands1)) +- DONE; +-}) +- +-(define_insn "*movti" +- (set (match_operand:TI 0 "nonimmediate_operand" "=r,r,r,m") +- (match_operand:TI 1 "move_operand" "r,i,m,rJ")) +- "TARGET_64BIT +- && (register_operand (operands0, TImode) +- || reg_or_0_operand (operands1, TImode))" +- { return loongarch_output_move (operands0, operands1); } +- (set_attr "move_type" "move,const,load,store") +- (set (attr "mode") +- (if_then_else (eq_attr "move_type" "imul") +- (const_string "SI") +- (const_string "TI")))) +- +-;; 128-bit floating point moves +- +-(define_expand "movtf" +- (set (match_operand:TF 0) +- (match_operand:TF 1)) +- "TARGET_64BIT" +-{ +- if (loongarch_legitimize_move (TFmode, operands0, operands1)) +- DONE; +-}) +- +-;; This pattern handles both hard- and soft-float cases. +-(define_insn "*movtf" +- (set (match_operand:TF 0 "nonimmediate_operand" "=r,r,m,f,r,f,m") +- (match_operand:TF 1 "move_operand" "rG,m,rG,rG,f,m,f")) +- "TARGET_64BIT +- && (register_operand (operands0, TFmode) +- || reg_or_0_operand (operands1, TFmode))" +- "#" +- (set_attr "move_type" "move,load,store,mgtf,mftg,fpload,fpstore") +- (set_attr "mode" "TF")) +- +-(define_split +- (set (match_operand:MOVE64 0 "nonimmediate_operand") +- (match_operand:MOVE64 1 "move_operand")) +- "reload_completed && loongarch_split_move_insn_p (operands0, operands1)" +- (const_int 0) +-{ +- loongarch_split_move_insn (operands0, operands1, curr_insn); +- DONE; +-}) +- +-(define_split +- (set (match_operand:MOVE128 0 "nonimmediate_operand") +- (match_operand:MOVE128 1 "move_operand")) +- "reload_completed && loongarch_split_move_insn_p (operands0, operands1)" +- (const_int 0) +-{ +- loongarch_split_move_insn (operands0, operands1, curr_insn); +- DONE; +-}) +- + ;; Emit a doubleword move in which exactly one of the operands is + ;; a floating-point register. We can't just emit two normal moves + ;; because of the constraints imposed by the FPU register model; +@@ -1938,6 +1875,57 @@ + (set_attr "type" "arith") + (set_attr "mode" "DI")) + ++;; Instructions for adding the low 12 bits of an address to a register. ++;; Operand 2 is the address: loongarch_print_operand works out which relocation ++;; should be applied. ++ ++(define_insn "*low<mode>" ++ (set (match_operand:P 0 "register_operand" "=r") ++ (lo_sum:P (match_operand:P 1 "register_operand" " r") ++ (match_operand:P 2 "symbolic_operand" ""))) ++ "TARGET_EXPLICIT_RELOCS" ++ "addi.<d>\t%0,%1,%L2" ++ (set_attr "type" "arith") ++ (set_attr "mode" "<MODE>")) ++ ++(define_insn "@tls_low<mode>" ++ (set (match_operand:P 0 "register_operand" "=r") ++ (unspec:P (mem:P (lo_sum:P (match_operand:P 1 "register_operand" "r") ++ (match_operand:P 2 "symbolic_operand" ""))) ++ UNSPEC_TLS_LOW)) ++ "TARGET_EXPLICIT_RELOCS" ++ "addi.<d>\t%0,%1,%L2" ++ (set_attr "type" "arith") ++ (set_attr "mode" "<MODE>")) ++ ++;; Instructions for loading address from GOT entry. ++;; operands1 is pc plus the high half of the address difference with the got ++;; entry; ++;; operands2 is low 12 bits for low 12 bit of the address difference with the ++;; got entry. ++;; loongarch_print_operand works out which relocation should be applied. ++ ++(define_insn "@ld_from_got<mode>" ++ (set (match_operand:P 0 "register_operand" "=r") ++ (unspec:P (mem:P (lo_sum:P ++ (match_operand:P 1 "register_operand" "r") ++ (match_operand:P 2 "symbolic_operand"))) ++ UNSPEC_LOAD_FROM_GOT)) ++ "TARGET_EXPLICIT_RELOCS" ++ "ld.<d>\t%0,%1,%L2" ++ (set_attr "type" "move") ++) ++ ++(define_insn "@ori_l_lo12<mode>" ++ (set (match_operand:P 0 "register_operand" "=r") ++ (unspec:P (match_operand:P 1 "register_operand" "r") ++ (match_operand:P 2 "symbolic_operand") ++ UNSPEC_ORI_L_LO12)) ++ "" ++ "ori\t%0,%1,%L2" ++ (set_attr "type" "move") ++) ++ + ;; Convert floating-point numbers to integers + (define_insn "frint_<fmt>" + (set (match_operand:ANYF 0 "register_operand" "=f") +diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt +index 3ff0d8604..7a8c5b444 100644 +--- a/gcc/config/loongarch/loongarch.opt ++++ b/gcc/config/loongarch/loongarch.opt +@@ -161,6 +161,10 @@ mmax-inline-memcpy-size= + Target Joined RejectNegative UInteger Var(loongarch_max_inline_memcpy_size) Init(1024) + -mmax-inline-memcpy-size=SIZE Set the max size of memcpy to inline, default is 1024. + ++mexplicit-relocs ++Target Var(TARGET_EXPLICIT_RELOCS) Init(1) ++Use %reloc() assembly operators. ++ + ; The code model option names for -mcmodel. + Enum + Name(cmodel) Type(int) +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index 2243ef71c..cd3528c7c 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -110,6 +110,10 @@ + (define_predicate "const_call_insn_operand" + (match_code "const,symbol_ref,label_ref") + { ++ /* Split symbol to high and low if return false. ++ If defined TARGET_CMODEL_LARGE, all symbol would be splited, ++ else if offset is not zero, the symbol would be splited. */ ++ + enum loongarch_symbol_type symbol_type; + loongarch_symbolic_constant_p (op, &symbol_type); + +@@ -125,7 +129,7 @@ + return 1; + + case SYMBOL_GOT_DISP: +- if (!flag_plt) ++ if (TARGET_CMODEL_LARGE || !flag_plt) + return false; + else + return 1; +@@ -213,7 +217,19 @@ + case CONST: + case SYMBOL_REF: + case LABEL_REF: +- return loongarch_symbolic_constant_p (op, &symbol_type); ++ return (loongarch_symbolic_constant_p (op, &symbol_type) ++ && (!TARGET_EXPLICIT_RELOCS ++ || !loongarch_split_symbol_type (symbol_type))); ++ ++ case HIGH: ++ /* '-mno-explicit-relocs' don't generate high/low pairs. */ ++ if (!TARGET_EXPLICIT_RELOCS) ++ return false; ++ ++ op = XEXP (op, 0); ++ return (loongarch_symbolic_constant_p (op, &symbol_type) ++ && loongarch_split_symbol_type (symbol_type)); ++ + default: + return true; + } +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-1.c b/gcc/testsuite/gcc.target/loongarch/func-call-1.c +index b0482761a..01b8ea23f 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-1.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-1.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fpic -fplt" } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mno-explicit-relocs" } */ + /* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ + /* { dg-final { scan-assembler "test1:.*bl\t%plt\\(f\\)\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-2.c b/gcc/testsuite/gcc.target/loongarch/func-call-2.c +index f5e061c29..4565baaec 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-2.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-2.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt" } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mno-explicit-relocs" } */ + /* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ + /* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-3.c b/gcc/testsuite/gcc.target/loongarch/func-call-3.c +index 75082c574..4f669a029 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-3.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-3.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt" } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mno-explicit-relocs" } */ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*la\.global\t.*f\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-4.c b/gcc/testsuite/gcc.target/loongarch/func-call-4.c +index e8a839549..943adb640 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-4.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-4.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt" } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mno-explicit-relocs" } */ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ + /* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-5.c b/gcc/testsuite/gcc.target/loongarch/func-call-5.c +new file mode 100644 +index 000000000..2c2a1c8a1 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-5.c +@@ -0,0 +1,33 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mexplicit-relocs" } */ ++/* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ ++/* { dg-final { scan-assembler "test1:.*bl\t%plt\\(f\\)\n" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-6.c b/gcc/testsuite/gcc.target/loongarch/func-call-6.c +new file mode 100644 +index 000000000..4b0e4266e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-6.c +@@ -0,0 +1,33 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mexplicit-relocs" } */ ++/* { dg-final { scan-assembler "test:.*bl\t%plt\\(g\\)\n" } } */ ++/* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-7.c b/gcc/testsuite/gcc.target/loongarch/func-call-7.c +new file mode 100644 +index 000000000..51792711f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-7.c +@@ -0,0 +1,34 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mexplicit-relocs" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%got_pc_hi20\\(f\\)\n\tld\.d\t.*%got_pc_lo12\\(f\\)\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-8.c b/gcc/testsuite/gcc.target/loongarch/func-call-8.c +new file mode 100644 +index 000000000..330140d88 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-8.c +@@ -0,0 +1,33 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mexplicit-relocs" } */ ++/* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ ++/* { dg-final { scan-assembler "test1:.*bl\tf\n" } } */ ++/* { dg-final { scan-assembler "test2:.*bl\tl\n" } } */ ++ ++extern void g (void); ++ ++void ++f (void) ++{} ++ ++static void ++l (void) ++{} ++ ++void ++test (void) ++{ ++ g (); ++} ++ ++void ++test1 (void) ++{ ++ f (); ++} ++ ++void ++test2 (void) ++{ ++ l (); ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c b/gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c +new file mode 100644 +index 000000000..bfcc9bc33 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/relocs-symbol-noaddend.c +@@ -0,0 +1,23 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mabi=lp64d -mexplicit-relocs -fno-pic -O2" } */ ++/* { dg-final { scan-assembler "pcalau12i.*%pc_hi20\\(\.LANCHOR0\\)\n" } } */ ++/* { dg-final { scan-assembler "addi\.d.*%pc_lo12\\(\.LANCHOR0\\)\n" } } */ ++/* { dg-final { scan-assembler "ldptr.d\t\\\$r4,.*,0\n" } } */ ++/* { dg-final { scan-assembler "ld.d\t\\\$r5,.*,8\n" } } */ ++/* { dg-final { scan-assembler-not "\.LANCHOR0+8" } } */ ++ ++ ++struct S ++{ ++ char *a; ++ unsigned short int b; ++}; ++ ++struct S s1; ++ ++void test(struct S); ++void test1(void) ++{ ++ test(s1); ++} ++ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Support-storing-floating-point-zero-into-M.patch
Added
@@ -0,0 +1,90 @@ +From de803130fa7d33afaf6e2fc42ef1cd97e45edf96 Mon Sep 17 00:00:00 2001 +From: Guo Jie <guojie@loongson.cn> +Date: Fri, 1 Sep 2023 16:35:05 +0800 +Subject: PATCH 057/124 LoongArch: Support storing floating-point zero into + MEMbase + index. + +v2: Modify commit message. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md: Support 'G' -> 'k' in + movsf_hardfloat and movdf_hardfloat. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/const-double-zero-stx.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 12 ++++++------ + .../loongarch/const-double-zero-stx.c | 18 ++++++++++++++++++ + 2 files changed, 24 insertions(+), 6 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/const-double-zero-stx.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index a5e9352ca..2d269794f 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -1915,13 +1915,13 @@ + }) + + (define_insn "*movsf_hardfloat" +- (set (match_operand:SF 0 "nonimmediate_operand" "=f,f,f,m,f,k,m,*f,*r,*r,*r,*m") +- (match_operand:SF 1 "move_operand" "f,G,m,f,k,f,G,*r,*f,*G*r,*m,*r")) ++ (set (match_operand:SF 0 "nonimmediate_operand" "=f,f,f,m,f,k,m,k,*f,*r,*r,*r,*m") ++ (match_operand:SF 1 "move_operand" "f,G,m,f,k,f,G,G,*r,*f,*G*r,*m,*r")) + "TARGET_HARD_FLOAT + && (register_operand (operands0, SFmode) + || reg_or_0_operand (operands1, SFmode))" + { return loongarch_output_move (operands0, operands1); } +- (set_attr "move_type" "fmove,mgtf,fpload,fpstore,fpload,fpstore,store,mgtf,mftg,move,load,store") ++ (set_attr "move_type" "fmove,mgtf,fpload,fpstore,fpload,fpstore,store,store,mgtf,mftg,move,load,store") + (set_attr "mode" "SF")) + + (define_insn "*movsf_softfloat" +@@ -1946,13 +1946,13 @@ + }) + + (define_insn "*movdf_hardfloat" +- (set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,m,f,k,m,*f,*r,*r,*r,*m") +- (match_operand:DF 1 "move_operand" "f,G,m,f,k,f,G,*r,*f,*r*G,*m,*r")) ++ (set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,m,f,k,m,k,*f,*r,*r,*r,*m") ++ (match_operand:DF 1 "move_operand" "f,G,m,f,k,f,G,G,*r,*f,*r*G,*m,*r")) + "TARGET_DOUBLE_FLOAT + && (register_operand (operands0, DFmode) + || reg_or_0_operand (operands1, DFmode))" + { return loongarch_output_move (operands0, operands1); } +- (set_attr "move_type" "fmove,mgtf,fpload,fpstore,fpload,fpstore,store,mgtf,mftg,move,load,store") ++ (set_attr "move_type" "fmove,mgtf,fpload,fpstore,fpload,fpstore,store,store,mgtf,mftg,move,load,store") + (set_attr "mode" "DF")) + + (define_insn "*movdf_softfloat" +diff --git a/gcc/testsuite/gcc.target/loongarch/const-double-zero-stx.c b/gcc/testsuite/gcc.target/loongarch/const-double-zero-stx.c +new file mode 100644 +index 000000000..8fb04be8f +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/const-double-zero-stx.c +@@ -0,0 +1,18 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++/* { dg-final { scan-assembler-times {stx\..\t\$r0} 2 } } */ ++ ++extern float arr_f; ++extern double arr_d; ++ ++void ++test_f (int base, int index) ++{ ++ arr_fbase + index = 0.0; ++} ++ ++void ++test_d (int base, int index) ++{ ++ arr_dbase + index = 0.0; ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Use-LSX-and-LASX-for-block-move.patch
Added
@@ -0,0 +1,154 @@ +From 01b932dead0e7bcc05aae2ac742c76b5fcac5ae7 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 5 Sep 2023 21:02:38 +0800 +Subject: PATCH 072/124 LoongArch: Use LSX and LASX for block move + +gcc/ChangeLog: + + * config/loongarch/loongarch.h (LARCH_MAX_MOVE_PER_INSN): + Define to the maximum amount of bytes able to be loaded or + stored with one machine instruction. + * config/loongarch/loongarch.cc (loongarch_mode_for_move_size): + New static function. + (loongarch_block_move_straight): Call + loongarch_mode_for_move_size for machine_mode to be moved. + (loongarch_expand_block_move): Use LARCH_MAX_MOVE_PER_INSN + instead of UNITS_PER_WORD. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/memcpy-vec-1.c: New test. + * gcc.target/loongarch/memcpy-vec-2.c: New test. + * gcc.target/loongarch/memcpy-vec-3.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 22 +++++++++++++++---- + gcc/config/loongarch/loongarch.h | 3 +++ + .../gcc.target/loongarch/memcpy-vec-1.c | 11 ++++++++++ + .../gcc.target/loongarch/memcpy-vec-2.c | 12 ++++++++++ + .../gcc.target/loongarch/memcpy-vec-3.c | 6 +++++ + 5 files changed, 50 insertions(+), 4 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/memcpy-vec-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/memcpy-vec-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 4b0944d56..baa5c2354 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -5187,6 +5187,20 @@ loongarch_function_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED, + return true; + } + ++static machine_mode ++loongarch_mode_for_move_size (HOST_WIDE_INT size) ++{ ++ switch (size) ++ { ++ case 32: ++ return V32QImode; ++ case 16: ++ return V16QImode; ++ } ++ ++ return int_mode_for_size (size * BITS_PER_UNIT, 0).require (); ++} ++ + /* Emit straight-line code to move LENGTH bytes from SRC to DEST. + Assume that the areas do not overlap. */ + +@@ -5216,7 +5230,7 @@ loongarch_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length, + + for (delta_cur = delta, i = 0, offs = 0; offs < length; delta_cur /= 2) + { +- mode = int_mode_for_size (delta_cur * BITS_PER_UNIT, 0).require (); ++ mode = loongarch_mode_for_move_size (delta_cur); + + for (; offs + delta_cur <= length; offs += delta_cur, i++) + { +@@ -5227,7 +5241,7 @@ loongarch_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length, + + for (delta_cur = delta, i = 0, offs = 0; offs < length; delta_cur /= 2) + { +- mode = int_mode_for_size (delta_cur * BITS_PER_UNIT, 0).require (); ++ mode = loongarch_mode_for_move_size (delta_cur); + + for (; offs + delta_cur <= length; offs += delta_cur, i++) + loongarch_emit_move (adjust_address (dest, mode, offs), regsi); +@@ -5322,8 +5336,8 @@ loongarch_expand_block_move (rtx dest, rtx src, rtx r_length, rtx r_align) + + HOST_WIDE_INT align = INTVAL (r_align); + +- if (!TARGET_STRICT_ALIGN || align > UNITS_PER_WORD) +- align = UNITS_PER_WORD; ++ if (!TARGET_STRICT_ALIGN || align > LARCH_MAX_MOVE_PER_INSN) ++ align = LARCH_MAX_MOVE_PER_INSN; + + if (length <= align * LARCH_MAX_MOVE_OPS_STRAIGHT) + { +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index b2295c589..c7e91a06d 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -1181,6 +1181,9 @@ typedef struct { + least twice. */ + #define LARCH_MAX_MOVE_OPS_STRAIGHT (LARCH_MAX_MOVE_OPS_PER_LOOP_ITER * 2) + ++#define LARCH_MAX_MOVE_PER_INSN \ ++ (ISA_HAS_LASX ? 32 : (ISA_HAS_LSX ? 16 : UNITS_PER_WORD)) ++ + /* The base cost of a memcpy call, for MOVE_RATIO and friends. These + values were determined experimentally by benchmarking with CSiBE. + */ +diff --git a/gcc/testsuite/gcc.target/loongarch/memcpy-vec-1.c b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-1.c +new file mode 100644 +index 000000000..8d9fedc9e +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-1.c +@@ -0,0 +1,11 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d -march=la464 -mno-strict-align" } */ ++/* { dg-final { scan-assembler-times "xvst" 2 } } */ ++/* { dg-final { scan-assembler-times "\tvst" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.d|stptr\\.d" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.w|stptr\\.w" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.h" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.b" 1 } } */ ++ ++extern char a, b; ++void test() { __builtin_memcpy(a, b, 95); } +diff --git a/gcc/testsuite/gcc.target/loongarch/memcpy-vec-2.c b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-2.c +new file mode 100644 +index 000000000..6b28b884d +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-2.c +@@ -0,0 +1,12 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mabi=lp64d -march=la464 -mno-strict-align" } */ ++/* { dg-final { scan-assembler-times "xvst" 2 } } */ ++/* { dg-final { scan-assembler-times "\tvst" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.d|stptr\\.d" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.w|stptr\\.w" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.h" 1 } } */ ++/* { dg-final { scan-assembler-times "st\\.b" 1 } } */ ++ ++typedef char __attribute__ ((vector_size (32), aligned (32))) vec; ++extern vec a, b; ++void test() { __builtin_memcpy(a, b, 95); } +diff --git a/gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c +new file mode 100644 +index 000000000..233ed2150 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/memcpy-vec-3.c +@@ -0,0 +1,6 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -march=la464 -mabi=lp64d -mstrict-align" } */ ++/* { dg-final { scan-assembler-not "vst" } } */ ++ ++extern char a, b; ++void test() { __builtin_memcpy(a, b, 16); } +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Use-UNSPEC-for-fmin-fmax-RTL-pattern-PR105.patch
Added
@@ -0,0 +1,68 @@ +From d6c7fe54314f7633d779da1a635a8f0832b8f4f6 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Sat, 24 Sep 2022 20:47:22 +0800 +Subject: PATCH 021/124 LoongArch: Use UNSPEC for fmin/fmax RTL pattern + PR105414 + +I made a mistake defining fmin/fmax RTL patterns in r13-2085: I used +smin and smax in the definition mistakenly. This causes the optimizer +to perform constant folding as if fmin/fmax was "really" smin/smax +operations even with -fsignaling-nans. Then pr105414.c fails. + +We don't have fmin/fmax RTL codes for now (PR107013) so we can only use +an UNSPEC for fmin and fmax patterns. + +gcc/ChangeLog: + + PR tree-optimization/105414 + * config/loongarch/loongarch.md (UNSPEC_FMAX): New unspec. + (UNSPEC_FMIN): Likewise. + (fmax<mode>3): Use UNSPEC_FMAX instead of smax. + (fmin<mode>3): Use UNSPEC_FMIN instead of smin. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 12 ++++++++---- + 1 file changed, 8 insertions(+), 4 deletions(-) + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 3787fd823..214b14bdd 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -35,6 +35,8 @@ + ;; Floating point unspecs. + UNSPEC_FRINT + UNSPEC_FCLASS ++ UNSPEC_FMAX ++ UNSPEC_FMIN + + ;; Override return address for exception handling. + UNSPEC_EH_RETURN +@@ -1032,8 +1034,9 @@ + + (define_insn "fmax<mode>3" + (set (match_operand:ANYF 0 "register_operand" "=f") +- (smax:ANYF (match_operand:ANYF 1 "register_operand" "f") +- (match_operand:ANYF 2 "register_operand" "f"))) ++ (unspec:ANYF (use (match_operand:ANYF 1 "register_operand" "f")) ++ (use (match_operand:ANYF 2 "register_operand" "f")) ++ UNSPEC_FMAX)) + "" + "fmax.<fmt>\t%0,%1,%2" + (set_attr "type" "fmove") +@@ -1041,8 +1044,9 @@ + + (define_insn "fmin<mode>3" + (set (match_operand:ANYF 0 "register_operand" "=f") +- (smin:ANYF (match_operand:ANYF 1 "register_operand" "f") +- (match_operand:ANYF 2 "register_operand" "f"))) ++ (unspec:ANYF (use (match_operand:ANYF 1 "register_operand" "f")) ++ (use (match_operand:ANYF 2 "register_operand" "f")) ++ UNSPEC_FMIN)) + "" + "fmin.<fmt>\t%0,%1,%2" + (set_attr "type" "fmove") +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-Use-bstrins-instruction-for-a-mask-and-a-m.patch
Added
@@ -0,0 +1,336 @@ +From 1c63c61f6508e3c718be79dd27dda25db2b291ee Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 5 Sep 2023 19:42:30 +0800 +Subject: PATCH 068/124 LoongArch: Use bstrins instruction for (a & ~mask) + and (a & mask) | (b & ~mask) PR111252 + +If mask is a constant with value ((1 << N) - 1) << M we can perform this +optimization. + +gcc/ChangeLog: + + PR target/111252 + * config/loongarch/loongarch-protos.h + (loongarch_pre_reload_split): Declare new function. + (loongarch_use_bstrins_for_ior_with_mask): Likewise. + * config/loongarch/loongarch.cc + (loongarch_pre_reload_split): Implement. + (loongarch_use_bstrins_for_ior_with_mask): Likewise. + * config/loongarch/predicates.md (ins_zero_bitmask_operand): + New predicate. + * config/loongarch/loongarch.md (bstrins_<mode>_for_mask): + New define_insn_and_split. + (bstrins_<mode>_for_ior_mask): Likewise. + (define_peephole2): Further optimize code sequence produced by + bstrins_<mode>_for_ior_mask if possible. + +gcc/testsuite/ChangeLog: + + * g++.target/loongarch/bstrins-compile.C: New test. + * g++.target/loongarch/bstrins-run.C: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-protos.h | 4 +- + gcc/config/loongarch/loongarch.cc | 36 ++++++++ + gcc/config/loongarch/loongarch.md | 91 +++++++++++++++++++ + gcc/config/loongarch/predicates.md | 8 ++ + .../g++.target/loongarch/bstrins-compile.C | 22 +++++ + .../g++.target/loongarch/bstrins-run.C | 65 +++++++++++++ + 6 files changed, 225 insertions(+), 1 deletion(-) + create mode 100644 gcc/testsuite/g++.target/loongarch/bstrins-compile.C + create mode 100644 gcc/testsuite/g++.target/loongarch/bstrins-run.C + +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 133ec9fa8..ea61cf567 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -56,7 +56,7 @@ enum loongarch_symbol_type { + }; + #define NUM_SYMBOL_TYPES (SYMBOL_TLSLDM + 1) + +-/* Routines implemented in loongarch.c. */ ++/* Routines implemented in loongarch.cc. */ + extern rtx loongarch_emit_move (rtx, rtx); + extern HOST_WIDE_INT loongarch_initial_elimination_offset (int, int); + extern void loongarch_expand_prologue (void); +@@ -163,6 +163,8 @@ extern const char *current_section_name (void); + extern unsigned int current_section_flags (void); + extern bool loongarch_use_ins_ext_p (rtx, HOST_WIDE_INT, HOST_WIDE_INT); + extern bool loongarch_check_zero_div_p (void); ++extern bool loongarch_pre_reload_split (void); ++extern int loongarch_use_bstrins_for_ior_with_mask (machine_mode, rtx *); + + union loongarch_gen_fn_ptrs + { +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index dae35a479..4b0944d56 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -5478,6 +5478,42 @@ loongarch_use_ins_ext_p (rtx op, HOST_WIDE_INT width, HOST_WIDE_INT bitpos) + return true; + } + ++/* Predicate for pre-reload splitters with associated instructions, ++ which can match any time before the split1 pass (usually combine), ++ then are unconditionally split in that pass and should not be ++ matched again afterwards. */ ++ ++bool loongarch_pre_reload_split (void) ++{ ++ return (can_create_pseudo_p () ++ && !(cfun->curr_properties & PROP_rtl_split_insns)); ++} ++ ++/* Check if we can use bstrins.<d> for ++ op0 = (op1 & op2) | (op3 & op4) ++ where op0, op1, op3 are regs, and op2, op4 are integer constants. */ ++int ++loongarch_use_bstrins_for_ior_with_mask (machine_mode mode, rtx *op) ++{ ++ unsigned HOST_WIDE_INT mask1 = UINTVAL (op2); ++ unsigned HOST_WIDE_INT mask2 = UINTVAL (op4); ++ ++ if (mask1 != ~mask2 || !mask1 || !mask2) ++ return 0; ++ ++ /* Try to avoid a right-shift. */ ++ if (low_bitmask_len (mode, mask1) != -1) ++ return -1; ++ ++ if (low_bitmask_len (mode, mask2 >> (ffs_hwi (mask2) - 1)) != -1) ++ return 1; ++ ++ if (low_bitmask_len (mode, mask1 >> (ffs_hwi (mask1) - 1)) != -1) ++ return -1; ++ ++ return 0; ++} ++ + /* Print the text for PRINT_OPERAND punctation character CH to FILE. + The punctuation characters are: + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 3dde0ceb1..11c18bf15 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -1322,6 +1322,97 @@ + (set_attr "move_type" "pick_ins") + (set_attr "mode" "<MODE>")) + ++(define_insn_and_split "*bstrins_<mode>_for_mask" ++ (set (match_operand:GPR 0 "register_operand") ++ (and:GPR (match_operand:GPR 1 "register_operand") ++ (match_operand:GPR 2 "ins_zero_bitmask_operand"))) ++ "" ++ "#" ++ "" ++ (set (match_dup 0) (match_dup 1)) ++ (set (zero_extract:GPR (match_dup 0) (match_dup 2) (match_dup 3)) ++ (const_int 0)) ++ { ++ unsigned HOST_WIDE_INT mask = ~UINTVAL (operands2); ++ int lo = ffs_hwi (mask) - 1; ++ int len = low_bitmask_len (<MODE>mode, mask >> lo); ++ ++ len = MIN (len, GET_MODE_BITSIZE (<MODE>mode) - lo); ++ operands2 = GEN_INT (len); ++ operands3 = GEN_INT (lo); ++ }) ++ ++(define_insn_and_split "*bstrins_<mode>_for_ior_mask" ++ (set (match_operand:GPR 0 "register_operand") ++ (ior:GPR (and:GPR (match_operand:GPR 1 "register_operand") ++ (match_operand:GPR 2 "const_int_operand")) ++ (and:GPR (match_operand:GPR 3 "register_operand") ++ (match_operand:GPR 4 "const_int_operand")))) ++ "loongarch_pre_reload_split () && \ ++ loongarch_use_bstrins_for_ior_with_mask (<MODE>mode, operands)" ++ "#" ++ "" ++ (set (match_dup 0) (match_dup 1)) ++ (set (zero_extract:GPR (match_dup 0) (match_dup 2) (match_dup 4)) ++ (match_dup 3)) ++ { ++ if (loongarch_use_bstrins_for_ior_with_mask (<MODE>mode, operands) < 0) ++ { ++ std::swap (operands1, operands3); ++ std::swap (operands2, operands4); ++ } ++ ++ unsigned HOST_WIDE_INT mask = ~UINTVAL (operands2); ++ int lo = ffs_hwi (mask) - 1; ++ int len = low_bitmask_len (<MODE>mode, mask >> lo); ++ ++ len = MIN (len, GET_MODE_BITSIZE (<MODE>mode) - lo); ++ operands2 = GEN_INT (len); ++ operands4 = GEN_INT (lo); ++ ++ if (lo) ++ { ++ rtx tmp = gen_reg_rtx (<MODE>mode); ++ emit_move_insn (tmp, gen_rtx_ASHIFTRT(<MODE>mode, operands3, ++ GEN_INT (lo))); ++ operands3 = tmp; ++ } ++ }) ++ ++;; We always avoid the shift operation in bstrins_<mode>_for_ior_mask ++;; if possible, but the result may be sub-optimal when one of the masks ++;; is (1 << N) - 1 and one of the src register is the dest register. ++;; For example: ++;; move t0, a0 ++;; move a0, a1 ++;; bstrins.d a0, t0, 42, 0 ++;; ret ++;; using a shift operation would be better: ++;; srai.d t0, a1, 43 ++;; bstrins.d a0, t0, 63, 43 ++;; ret ++;; unfortunately we cannot figure it out in split1: before reload we cannot ++;; know if the dest register is one of the src register. Fix it up in ++;; peephole2. ++(define_peephole2 ++ (set (match_operand:GPR 0 "register_operand") ++ (match_operand:GPR 1 "register_operand")) ++ (set (match_dup 1) (match_operand:GPR 2 "register_operand")) ++ (set (zero_extract:GPR (match_dup 1) ++ (match_operand:SI 3 "const_int_operand") ++ (const_int 0)) ++ (match_dup 0)) ++ "peep2_reg_dead_p (3, operands0)" ++ (const_int 0) ++ { ++ int len = GET_MODE_BITSIZE (<MODE>mode) - INTVAL (operands3); ++ ++ emit_insn (gen_ashr<mode>3 (operands0, operands2, operands3)); ++ emit_insn (gen_insv<mode> (operands1, GEN_INT (len), operands3, ++ operands0)); ++ DONE; ++ }) ++ + (define_insn "*iorhi3" + (set (match_operand:HI 0 "register_operand" "=r,r") + (ior:HI (match_operand:HI 1 "register_operand" "%r,r") +diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md +index cf9361b73..ad6cee5c4 100644 +--- a/gcc/config/loongarch/predicates.md ++++ b/gcc/config/loongarch/predicates.md +@@ -408,6 +408,14 @@ + (define_predicate "muldiv_target_operand" + (match_operand 0 "register_operand")) + ++(define_predicate "ins_zero_bitmask_operand" ++ (and (match_code "const_int") ++ (match_test "INTVAL (op) != -1") ++ (match_test "INTVAL (op) & 1") ++ (match_test "low_bitmask_len (mode, \ ++ ~UINTVAL (op) | (~UINTVAL(op) - 1)) \ ++ > 12"))) ++ + (define_predicate "const_call_insn_operand" + (match_code "const,symbol_ref,label_ref") + { +diff --git a/gcc/testsuite/g++.target/loongarch/bstrins-compile.C b/gcc/testsuite/g++.target/loongarch/bstrins-compile.C +new file mode 100644 +index 000000000..3c0db1de4 +--- /dev/null ++++ b/gcc/testsuite/g++.target/loongarch/bstrins-compile.C +@@ -0,0 +1,22 @@ ++/* { dg-do compile } */ ++/* { dg-options "-std=c++14 -O2 -march=loongarch64 -mabi=lp64d" } */ ++/* { dg-final { scan-assembler "bstrins\\.d.*7,4" } } */ ++/* { dg-final { scan-assembler "bstrins\\.d.*15,4" } } */ ++/* { dg-final { scan-assembler "bstrins\\.d.*31,4" } } */ ++/* { dg-final { scan-assembler "bstrins\\.d.*47,4" } } */ ++/* { dg-final { scan-assembler "bstrins\\.d.*3,0" } } */ ++ ++typedef unsigned long u64; ++ ++template <u64 mask> ++u64 ++test (u64 a, u64 b) ++{ ++ return (a & mask) | (b & ~mask); ++} ++ ++template u64 test<0x0000'0000'0000'00f0l> (u64, u64); ++template u64 test<0x0000'0000'0000'fff0l> (u64, u64); ++template u64 test<0x0000'0000'ffff'fff0l> (u64, u64); ++template u64 test<0x0000'ffff'ffff'fff0l> (u64, u64); ++template u64 test<0xffff'ffff'ffff'fff0l> (u64, u64); +diff --git a/gcc/testsuite/g++.target/loongarch/bstrins-run.C b/gcc/testsuite/g++.target/loongarch/bstrins-run.C +new file mode 100644 +index 000000000..68913d5e0 +--- /dev/null ++++ b/gcc/testsuite/g++.target/loongarch/bstrins-run.C +@@ -0,0 +1,65 @@ ++/* { dg-do run } */ ++/* { dg-options "-O2" } */ ++ ++typedef unsigned long gr; ++ ++template <int l, int r> ++struct mask { ++ enum { value = (1ul << r) - (1ul << l) }; ++}; ++ ++template <int l> ++struct mask<l, sizeof (gr) * __CHAR_BIT__> { ++ enum { value = -(1ul << l) }; ++}; ++ ++__attribute__ ((noipa)) void ++test (gr a, gr b, gr mask, gr out) ++{ ++ if (((a & mask) | (b & ~mask)) != out) ++ __builtin_abort (); ++} ++ ++__attribute__ ((noipa)) gr ++no_optimize (gr x) ++{ ++ return x; ++} ++ ++template <int l, int r> ++struct test1 { ++ static void ++ run (void) ++ { ++ gr m = mask<l, r>::value; ++ gr a = no_optimize (-1ul); ++ gr b = no_optimize (0); ++ ++ test (a, b, m, (a & m) | (b & ~m)); ++ test (a, b, ~m, (a & ~m) | (b & m)); ++ test (a, 0, ~m, a & ~m); ++ ++ test1<l, r + 1>::run (); ++ } ++}; ++ ++template <int l> ++struct test1<l, sizeof (gr) * __CHAR_BIT__ + 1> { ++ static void run (void) {} ++}; ++ ++template <int l> ++void ++test2 (void) ++{ ++ test1<l, l + 1>::run (); ++ test2<l + 1> (); ++} ++ ++template <> void test2<sizeof (gr) * __CHAR_BIT__> (void) {} ++ ++int ++main () ++{ ++ test2<0> (); ++} +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-add-mdirect-extern-access-option.patch
Added
@@ -0,0 +1,157 @@ +From 22f6d3fad184d87f3dac7634537fdbc24846bab9 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Thu, 1 Sep 2022 18:38:14 +0800 +Subject: PATCH 016/124 LoongArch: add -mdirect-extern-access option + +As a new target, LoongArch does not use copy relocation as it's +problematic in some circumstances. One bad consequence is we are +emitting GOT for all accesses to all extern objects with default +visibility. The use of GOT is not needed in statically linked +executables, OS kernels etc. The GOT entry just wastes space, and the +GOT access just slow down the execution in those environments. + +Before -mexplicit-relocs, we used "-Wa,-mla-global-with-pcrel" to tell +the assembler not to use GOT for extern access. But with +-mexplicit-relocs, we have to opt the logic in GCC. + +The name "-mdirect-extern-access" is learnt from x86 port. + +gcc/ChangeLog: + + * config/loongarch/genopts/loongarch.opt.in: Add + -mdirect-extern-access option. + * config/loongarch/loongarch.opt: Regenerate. + * config/loongarch/loongarch.cc + (loongarch_symbol_binds_local_p): Return true if + TARGET_DIRECT_EXTERN_ACCESS. + (loongarch_option_override_internal): Complain if + -mdirect-extern-access is used with -fPIC or -fpic. + * doc/invoke.texi: Document -mdirect-extern-access for + LoongArch. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/direct-extern-1.c: New test. + * gcc.target/loongarch/direct-extern-2.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/genopts/loongarch.opt.in | 4 ++++ + gcc/config/loongarch/loongarch.cc | 6 ++++++ + gcc/config/loongarch/loongarch.opt | 4 ++++ + gcc/doc/invoke.texi | 15 +++++++++++++++ + .../gcc.target/loongarch/direct-extern-1.c | 6 ++++++ + .../gcc.target/loongarch/direct-extern-2.c | 6 ++++++ + 6 files changed, 41 insertions(+) + create mode 100644 gcc/testsuite/gcc.target/loongarch/direct-extern-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/direct-extern-2.c + +diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in +index ebdd9538d..e10618777 100644 +--- a/gcc/config/loongarch/genopts/loongarch.opt.in ++++ b/gcc/config/loongarch/genopts/loongarch.opt.in +@@ -184,3 +184,7 @@ Enum(cmodel) String(@@STR_CMODEL_EXTREME@@) Value(CMODEL_EXTREME) + mcmodel= + Target RejectNegative Joined Enum(cmodel) Var(la_opt_cmodel) Init(CMODEL_NORMAL) + Specify the code model. ++ ++mdirect-extern-access ++Target Var(TARGET_DIRECT_EXTERN_ACCESS) Init(0) ++Avoid using the GOT to access external symbols. +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 77e3a1053..c9187bf81 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -1610,6 +1610,9 @@ loongarch_weak_symbol_p (const_rtx x) + bool + loongarch_symbol_binds_local_p (const_rtx x) + { ++ if (TARGET_DIRECT_EXTERN_ACCESS) ++ return true; ++ + if (SYMBOL_REF_P (x)) + return (SYMBOL_REF_DECL (x) + ? targetm.binds_local_p (SYMBOL_REF_DECL (x)) +@@ -6093,6 +6096,9 @@ loongarch_option_override_internal (struct gcc_options *opts) + if (loongarch_branch_cost == 0) + loongarch_branch_cost = loongarch_cost->branch_cost; + ++ if (TARGET_DIRECT_EXTERN_ACCESS && flag_shlib) ++ error ("%qs cannot be used for compiling a shared library", ++ "-mdirect-extern-access"); + + switch (la_target.cmodel) + { +diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt +index 639523421..96c811c85 100644 +--- a/gcc/config/loongarch/loongarch.opt ++++ b/gcc/config/loongarch/loongarch.opt +@@ -191,3 +191,7 @@ Enum(cmodel) String(extreme) Value(CMODEL_EXTREME) + mcmodel= + Target RejectNegative Joined Enum(cmodel) Var(la_opt_cmodel) Init(CMODEL_NORMAL) + Specify the code model. ++ ++mdirect-extern-access ++Target Var(TARGET_DIRECT_EXTERN_ACCESS) Init(0) ++Avoid using the GOT to access external symbols. +diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi +index 2a5592516..9ec937b84 100644 +--- a/gcc/doc/invoke.texi ++++ b/gcc/doc/invoke.texi +@@ -1007,6 +1007,7 @@ Objective-C and Objective-C++ Dialects}. + -memcpy -mno-memcpy -mstrict-align -mno-strict-align @gol + -mmax-inline-memcpy-size=@var{n} @gol + -mexplicit-relocs -mno-explicit-relocs @gol ++-mdirect-extern-access -mno-direct-extern-access @gol + -mcmodel=@var{code-model}} + + @emph{M32R/D Options} +@@ -24649,6 +24650,20 @@ GCC build-time by detecting corresponding assembler support: + @code{-mno-explicit-relocs} otherwise. This option is mostly useful for + debugging, or interoperation with assemblers different from the build-time + one. ++ ++@item -mdirect-extern-access ++@itemx -mno-direct-extern-access ++@opindex mdirect-extern-access ++Do not use or use GOT to access external symbols. The default is ++@option{-mno-direct-extern-access}: GOT is used for external symbols with ++default visibility, but not used for other external symbols. ++ ++With @option{-mdirect-extern-access}, GOT is not used and all external ++symbols are PC-relatively addressed. It is @strong{only} suitable for ++environments where no dynamic link is performed, like firmwares, OS ++kernels, executables linked with @option{-static} or @option{-static-pie}. ++@option{-mdirect-extern-access} is not compatible with @option{-fPIC} or ++@option{-fpic}. + @end table + + @node M32C Options +diff --git a/gcc/testsuite/gcc.target/loongarch/direct-extern-1.c b/gcc/testsuite/gcc.target/loongarch/direct-extern-1.c +new file mode 100644 +index 000000000..85c6c1e8a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/direct-extern-1.c +@@ -0,0 +1,6 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mexplicit-relocs -mdirect-extern-access" } */ ++/* { dg-final { scan-assembler-not "got" } } */ ++ ++extern int x; ++int f() { return x; } +diff --git a/gcc/testsuite/gcc.target/loongarch/direct-extern-2.c b/gcc/testsuite/gcc.target/loongarch/direct-extern-2.c +new file mode 100644 +index 000000000..58d8bd68a +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/direct-extern-2.c +@@ -0,0 +1,6 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mno-explicit-relocs -mdirect-extern-access" } */ ++/* { dg-final { scan-assembler-not "la.global" } } */ ++ ++extern int x; ++int f() { return x; } +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-add-model-attribute.patch
Added
@@ -0,0 +1,477 @@ +From 859ed9ee2dc28b98e11b2bfdeabb0bda7dc921b0 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Fri, 29 Jul 2022 21:45:40 +0800 +Subject: PATCH 014/124 LoongArch: add model attribute + +A linker script and/or a section attribute may locate some object +specially, so we need to handle the code model for such objects +differently than the -mcmodel setting. This happens when the Linux +kernel loads a module with per-CPU variables. + +Add an attribute to override the code model for a specific variable. + +gcc/ChangeLog: + + * config/loongarch/loongarch-protos.h (loongarch_symbol_type): + Add SYMBOL_PCREL64 and change the description for SYMBOL_PCREL. + * config/loongarch/loongarch.cc (loongarch_attribute_table): + New attribute table. + (TARGET_ATTRIBUTE_TABLE): Define the target hook. + (loongarch_handle_model_attribute): New static function. + (loongarch_classify_symbol): Take TARGET_CMODEL_EXTREME and the + model attribute of SYMBOL_REF_DECL into account returning + SYMBOL_PCREL or SYMBOL_PCREL64. + (loongarch_use_anchors_for_symbol_p): New static function. + (TARGET_USE_ANCHORS_FOR_SYMBOL_P): Define the target hook. + (loongarch_symbol_extreme_p): New static function. + (loongarch_symbolic_constant_p): Handle SYMBOL_PCREL64. + (loongarch_symbol_insns): Likewise. + (loongarch_split_symbol_type): Likewise. + (loongarch_split_symbol): Check SYMBOL_PCREL64 instead of + TARGET_CMODEL_EXTREME for PC-relative addressing. + (loongarch_print_operand_reloc): Likewise. + * doc/extend.texi (Variable Attributes): Document new + LoongArch specific attribute. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/attr-model-test.c: New test. + * gcc.target/loongarch/attr-model-1.c: New test. + * gcc.target/loongarch/attr-model-2.c: New test. + * gcc.target/loongarch/attr-model-diag.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-protos.h | 8 +- + gcc/config/loongarch/loongarch.cc | 190 ++++++++++++++++-- + gcc/doc/extend.texi | 17 ++ + .../gcc.target/loongarch/attr-model-1.c | 6 + + .../gcc.target/loongarch/attr-model-2.c | 6 + + .../gcc.target/loongarch/attr-model-diag.c | 7 + + .../gcc.target/loongarch/attr-model-test.c | 25 +++ + 7 files changed, 238 insertions(+), 21 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/attr-model-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/attr-model-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/attr-model-diag.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/attr-model-test.c + +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index cadaad751..77b221724 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -28,7 +28,12 @@ along with GCC; see the file COPYING3. If not see + The symbol's value will be loaded directly from the GOT. + + SYMBOL_PCREL +- The symbol's value will be loaded directly from data section. ++ The symbol's value will be loaded directly from data section within ++ +/- 2GiB range. ++ ++ SYMBOL_PCREL64 ++ The symbol's value will be loaded directly from data section within ++ +/- 8EiB range. + + SYMBOL_TLS + A thread-local symbol. +@@ -42,6 +47,7 @@ along with GCC; see the file COPYING3. If not see + enum loongarch_symbol_type { + SYMBOL_GOT_DISP, + SYMBOL_PCREL, ++ SYMBOL_PCREL64, + SYMBOL_TLS, + SYMBOL_TLS_IE, + SYMBOL_TLS_LE, +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 452aba9d4..77e3a1053 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -1633,8 +1633,11 @@ loongarch_rtx_constant_in_small_data_p (machine_mode mode) + static enum loongarch_symbol_type + loongarch_classify_symbol (const_rtx x) + { ++ enum loongarch_symbol_type pcrel = ++ TARGET_CMODEL_EXTREME ? SYMBOL_PCREL64 : SYMBOL_PCREL; ++ + if (!SYMBOL_REF_P (x)) +- return SYMBOL_PCREL; ++ return pcrel; + + if (SYMBOL_REF_TLS_MODEL (x)) + return SYMBOL_TLS; +@@ -1642,7 +1645,28 @@ loongarch_classify_symbol (const_rtx x) + if (!loongarch_symbol_binds_local_p (x)) + return SYMBOL_GOT_DISP; + +- return SYMBOL_PCREL; ++ tree t = SYMBOL_REF_DECL (x); ++ if (!t) ++ return pcrel; ++ ++ t = lookup_attribute ("model", DECL_ATTRIBUTES (t)); ++ if (!t) ++ return pcrel; ++ ++ t = TREE_VALUE (TREE_VALUE (t)); ++ ++ /* loongarch_handle_model_attribute should reject other values. */ ++ gcc_assert (TREE_CODE (t) == STRING_CST); ++ ++ const char *model = TREE_STRING_POINTER (t); ++ if (strcmp (model, "normal") == 0) ++ return SYMBOL_PCREL; ++ if (strcmp (model, "extreme") == 0) ++ return SYMBOL_PCREL64; ++ ++ /* loongarch_handle_model_attribute should reject unknown model ++ name. */ ++ gcc_unreachable (); + } + + /* Classify the base of symbolic expression X, given that X appears in +@@ -1695,6 +1719,7 @@ loongarch_symbolic_constant_p (rtx x, enum loongarch_symbol_type *symbol_type) + case SYMBOL_TLSGD: + case SYMBOL_TLSLDM: + case SYMBOL_PCREL: ++ case SYMBOL_PCREL64: + /* GAS rejects offsets outside the range -2^31, 2^31-1. */ + return sext_hwi (INTVAL (offset), 32) == INTVAL (offset); + +@@ -1729,6 +1754,9 @@ loongarch_symbol_insns (enum loongarch_symbol_type type, machine_mode mode) + case SYMBOL_TLSLDM: + return 3; + ++ case SYMBOL_PCREL64: ++ return 5; ++ + case SYMBOL_TLS: + /* We don't treat a bare TLS symbol as a constant. */ + return 0; +@@ -1833,7 +1861,7 @@ loongarch_valid_offset_p (rtx x, machine_mode mode) + return true; + } + +-/* Should a symbol of type SYMBOL_TYPE should be split in two? */ ++/* Should a symbol of type SYMBOL_TYPE should be split in two or more? */ + + bool + loongarch_split_symbol_type (enum loongarch_symbol_type symbol_type) +@@ -1841,6 +1869,7 @@ loongarch_split_symbol_type (enum loongarch_symbol_type symbol_type) + switch (symbol_type) + { + case SYMBOL_PCREL: ++ case SYMBOL_PCREL64: + case SYMBOL_GOT_DISP: + case SYMBOL_TLS_IE: + case SYMBOL_TLS_LE: +@@ -2718,6 +2747,20 @@ loongarch_force_address (rtx x, machine_mode mode) + return x; + } + ++static bool ++loongarch_symbol_extreme_p (enum loongarch_symbol_type type) ++{ ++ switch (type) ++ { ++ case SYMBOL_PCREL: ++ return false; ++ case SYMBOL_PCREL64: ++ return true; ++ default: ++ return TARGET_CMODEL_EXTREME; ++ } ++} ++ + /* If MODE is MAX_MACHINE_MODE, ADDR appears as a move operand, otherwise + it appears in a MEM of that mode. Return true if ADDR is a legitimate + constant in that context and can be split into high and low parts. +@@ -2757,7 +2800,7 @@ loongarch_split_symbol (rtx temp, rtx addr, machine_mode mode, rtx *low_out) + high = gen_rtx_HIGH (Pmode, copy_rtx (addr)); + high = loongarch_force_temporary (temp, high); + +- if (TARGET_CMODEL_EXTREME && can_create_pseudo_p ()) ++ if (loongarch_symbol_extreme_p (symbol_type) && can_create_pseudo_p ()) + { + gcc_assert (TARGET_EXPLICIT_RELOCS); + +@@ -2771,14 +2814,16 @@ loongarch_split_symbol (rtx temp, rtx addr, machine_mode mode, rtx *low_out) + if (low_out) + switch (symbol_type) + { +- case SYMBOL_PCREL: +- { +- if (TARGET_CMODEL_EXTREME && can_create_pseudo_p ()) ++ case SYMBOL_PCREL64: ++ if (can_create_pseudo_p ()) ++ { + *low_out = gen_rtx_PLUS (Pmode, high, temp1); +- else +- *low_out = gen_rtx_LO_SUM (Pmode, high, addr); +- break; +- } ++ break; ++ } ++ /* fall through */ ++ case SYMBOL_PCREL: ++ *low_out = gen_rtx_LO_SUM (Pmode, high, addr); ++ break; + + case SYMBOL_GOT_DISP: + /* SYMBOL_GOT_DISP symbols are loaded from the GOT. */ +@@ -4745,22 +4790,23 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part, + bool hi_reloc) + { + const char *reloc; ++ enum loongarch_symbol_type symbol_type = ++ loongarch_classify_symbolic_expression (op); + +- if (TARGET_CMODEL_EXTREME) ++ if (loongarch_symbol_extreme_p (symbol_type)) + gcc_assert (TARGET_EXPLICIT_RELOCS); + +- switch (loongarch_classify_symbolic_expression (op)) ++ switch (symbol_type) + { +- case SYMBOL_PCREL: ++ case SYMBOL_PCREL64: + if (hi64_part) + { +- if (TARGET_CMODEL_EXTREME) +- reloc = hi_reloc ? "%pc64_hi12" : "%pc64_lo20"; +- else +- gcc_unreachable (); ++ reloc = hi_reloc ? "%pc64_hi12" : "%pc64_lo20"; ++ break; + } +- else +- reloc = hi_reloc ? "%pc_hi20" : "%pc_lo12"; ++ /* fall through */ ++ case SYMBOL_PCREL: ++ reloc = hi_reloc ? "%pc_hi20" : "%pc_lo12"; + break; + + case SYMBOL_GOT_DISP: +@@ -6316,6 +6362,104 @@ loongarch_starting_frame_offset (void) + return crtl->outgoing_args_size; + } + ++static tree ++loongarch_handle_model_attribute (tree *node, tree name, tree arg, int, ++ bool *no_add_attrs) ++{ ++ tree decl = *node; ++ if (TREE_CODE (decl) == VAR_DECL) ++ { ++ if (DECL_THREAD_LOCAL_P (decl)) ++ { ++ error_at (DECL_SOURCE_LOCATION (decl), ++ "%qE attribute cannot be specified for thread-local " ++ "variables", name); ++ *no_add_attrs = true; ++ return NULL_TREE; ++ } ++ if (DECL_CONTEXT (decl) ++ && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL ++ && !TREE_STATIC (decl)) ++ { ++ error_at (DECL_SOURCE_LOCATION (decl), ++ "%qE attribute cannot be specified for local " ++ "variables", name); ++ *no_add_attrs = true; ++ return NULL_TREE; ++ } ++ if (DECL_REGISTER (decl)) ++ { ++ error_at (DECL_SOURCE_LOCATION (decl), ++ "%qE attribute cannot be specified for register " ++ "variables", name); ++ *no_add_attrs = true; ++ return NULL_TREE; ++ } ++ if (!TARGET_EXPLICIT_RELOCS) ++ { ++ error_at (DECL_SOURCE_LOCATION (decl), ++ "%qE attribute requires %s", name, "-mexplicit-relocs"); ++ *no_add_attrs = true; ++ return NULL_TREE; ++ } ++ ++ arg = TREE_VALUE (arg); ++ if (TREE_CODE (arg) != STRING_CST) ++ { ++ error_at (DECL_SOURCE_LOCATION (decl), ++ "invalid argument of %qE attribute", name); ++ *no_add_attrs = true; ++ return NULL_TREE; ++ } ++ ++ const char *model = TREE_STRING_POINTER (arg); ++ if (strcmp (model, "normal") != 0 ++ && strcmp (model, "extreme") != 0) ++ { ++ error_at (DECL_SOURCE_LOCATION (decl), ++ "invalid argument of %qE attribute", name); ++ *no_add_attrs = true; ++ return NULL_TREE; ++ } ++ ++ if (lookup_attribute ("model", DECL_ATTRIBUTES (decl))) ++ { ++ error_at (DECL_SOURCE_LOCATION (decl), ++ "multiple %qE attribute", name); ++ *no_add_attrs = true; ++ return NULL_TREE; ++ } ++ } ++ else ++ { ++ warning (OPT_Wattributes, "%qE attribute ignored", name); ++ *no_add_attrs = true; ++ } ++ return NULL_TREE; ++} ++ ++static const struct attribute_spec loongarch_attribute_table = ++{ ++ /* { name, min_len, max_len, decl_req, type_req, fn_type_req, ++ affects_type_identity, handler, exclude } */ ++ { "model", 1, 1, true, false, false, false, ++ loongarch_handle_model_attribute, NULL }, ++ /* The last attribute spec is set to be NULL. */ ++ {} ++}; ++ ++bool ++loongarch_use_anchors_for_symbol_p (const_rtx symbol) ++{ ++ tree decl = SYMBOL_REF_DECL (symbol); ++ ++ /* The section anchor optimization may break custom address model. */ ++ if (decl && lookup_attribute ("model", DECL_ATTRIBUTES (decl))) ++ return false; ++ ++ return default_use_anchors_for_symbol_p (symbol); ++} ++ + /* Initialize the GCC target structure. */ + #undef TARGET_ASM_ALIGNED_HI_OP + #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t" +@@ -6504,6 +6648,12 @@ loongarch_starting_frame_offset (void) + #undef TARGET_HAVE_SPECULATION_SAFE_VALUE + #define TARGET_HAVE_SPECULATION_SAFE_VALUE speculation_safe_value_not_needed + ++#undef TARGET_ATTRIBUTE_TABLE ++#define TARGET_ATTRIBUTE_TABLE loongarch_attribute_table ++ ++#undef TARGET_USE_ANCHORS_FOR_SYMBOL_P ++#define TARGET_USE_ANCHORS_FOR_SYMBOL_P loongarch_use_anchors_for_symbol_p ++ + struct gcc_target targetm = TARGET_INITIALIZER; + + #include "gt-loongarch.h" +diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi +index 33a776a79..da2840c23 100644 +--- a/gcc/doc/extend.texi ++++ b/gcc/doc/extend.texi +@@ -7277,6 +7277,7 @@ attributes. + * Blackfin Variable Attributes:: + * H8/300 Variable Attributes:: + * IA-64 Variable Attributes:: ++* LoongArch Variable Attributes:: + * M32R/D Variable Attributes:: + * MeP Variable Attributes:: + * Microsoft Windows Variable Attributes:: +@@ -8061,6 +8062,22 @@ defined by shared libraries. + + @end table + ++@node LoongArch Variable Attributes ++@subsection LoongArch Variable Attributes ++ ++One attribute is currently defined for the LoongArch. ++ ++@table @code ++@item model("@var{name}") ++@cindex @code{model} variable attribute, LoongArch ++Use this attribute on the LoongArch to use a different code model for ++addressing this variable, than the code model specified by the global ++@option{-mcmodel} option. This attribute is mostly useful if a ++@code{section} attribute and/or a linker script will locate this object ++specially. Currently the only supported values of @var{name} are ++@code{normal} and @code{extreme}. ++@end table ++ + @node M32R/D Variable Attributes + @subsection M32R/D Variable Attributes + +diff --git a/gcc/testsuite/gcc.target/loongarch/attr-model-1.c b/gcc/testsuite/gcc.target/loongarch/attr-model-1.c +new file mode 100644 +index 000000000..916d715b9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/attr-model-1.c +@@ -0,0 +1,6 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mexplicit-relocs -mcmodel=normal -O2" } */ ++/* { dg-final { scan-assembler-times "%pc64_hi12" 2 } } */ ++ ++#define ATTR_MODEL_TEST ++#include "attr-model-test.c" +diff --git a/gcc/testsuite/gcc.target/loongarch/attr-model-2.c b/gcc/testsuite/gcc.target/loongarch/attr-model-2.c +new file mode 100644 +index 000000000..a74c795ac +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/attr-model-2.c +@@ -0,0 +1,6 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mexplicit-relocs -mcmodel=extreme -O2" } */ ++/* { dg-final { scan-assembler-times "%pc64_hi12" 3 } } */ ++ ++#define ATTR_MODEL_TEST ++#include "attr-model-test.c" +diff --git a/gcc/testsuite/gcc.target/loongarch/attr-model-diag.c b/gcc/testsuite/gcc.target/loongarch/attr-model-diag.c +new file mode 100644 +index 000000000..88beede74 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/attr-model-diag.c +@@ -0,0 +1,7 @@ ++/* { dg-do compile } */ ++/* { dg-options "-mexplicit-relocs" } */ ++ ++__thread int x __attribute__((model("extreme"))); /* { dg-error "attribute cannot be specified for thread-local variables" } */ ++register int y __asm__("tp") __attribute__((model("extreme"))); /* { dg-error "attribute cannot be specified for register variables" } */ ++int z __attribute__((model(114))); /* { dg-error "invalid argument" } */ ++int t __attribute__((model("good"))); /* { dg-error "invalid argument" } */ +diff --git a/gcc/testsuite/gcc.target/loongarch/attr-model-test.c b/gcc/testsuite/gcc.target/loongarch/attr-model-test.c +new file mode 100644 +index 000000000..5b61a7af9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/attr-model-test.c +@@ -0,0 +1,25 @@ ++#ifdef ATTR_MODEL_TEST ++int x __attribute__((model("extreme"))); ++int y __attribute__((model("normal"))); ++int z; ++ ++int ++test(void) ++{ ++ return x + y + z; ++} ++ ++/* The following will be used for kernel per-cpu storage implemention. */ ++ ++register char *per_cpu_base __asm__("r21"); ++static int counter __attribute__((section(".data..percpu"), model("extreme"))); ++ ++void ++inc_counter(void) ++{ ++ int *ptr = (int *)(per_cpu_base + (long)&counter); ++ (*ptr)++; ++} ++#endif ++ ++int dummy; +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-add-new-configure-option-with-strict-align.patch
Added
@@ -0,0 +1,86 @@ +From da22606529688b125e6e08589a6dfe741b8dd18d Mon Sep 17 00:00:00 2001 +From: Yang Yujie <yangyujie@loongson.cn> +Date: Mon, 28 Aug 2023 10:20:12 +0800 +Subject: PATCH 060/124 LoongArch: add new configure option + --with-strict-align-lib + +LoongArch processors may not support memory accesses without natural +alignments. Building libraries with -mstrict-align may help with +toolchain binary compatiblity and performance on these implementations +(e.g. Loongson 2K1000LA). + +No significant performance degredation is observed on current mainstream +LoongArch processors when the option is enabled. + +gcc/ChangeLog: + + * config.gcc: use -mstrict-align for building libraries + if --with-strict-align-lib is given. + * doc/install.texi: likewise. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config.gcc | 16 +++++++++++++++- + gcc/doc/install.texi | 4 ++++ + 2 files changed, 19 insertions(+), 1 deletion(-) + +diff --git a/gcc/config.gcc b/gcc/config.gcc +index 62525c296..16bbaea45 100644 +--- a/gcc/config.gcc ++++ b/gcc/config.gcc +@@ -4966,7 +4966,7 @@ case "${target}" in + ;; + + loongarch*-*) +- supported_defaults="abi arch tune fpu simd multilib-default" ++ supported_defaults="abi arch tune fpu simd multilib-default strict-align-lib" + + # Local variables + unset \ +@@ -5163,6 +5163,17 @@ case "${target}" in + ;; + esac + ++ # Build libraries with -mstrict-align if --with-strict-align-lib is given. ++ case ${with_strict_align_lib} in ++ yes) strict_align_opt="/mstrict-align" ;; ++ ""|no) ;; ++ *) ++ echo "Unknown option: --with-strict-align-lib=${with_strict_align_lib}" 1>&2 ++ exit 1 ++ ;; ++ esac ++ ++ + # Handle --with-multilib-default + if echo "${with_multilib_default}" \ + | grep -E -e ':space:' -e '//' -e '/$' -e '^/' > /dev/null 2>&1; then +@@ -5324,6 +5335,9 @@ case "${target}" in + ;; + esac + ++ # Use mstrict-align for building libraries if --with-strict-align-lib is given. ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}${strict_align_opt}" ++ + # Check for repeated configuration of the same multilib variant. + if echo "${elem_abi_base}/${elem_abi_ext}" \ + | grep -E "^(${all_abis%|})$" >/dev/null 2>&1; then +diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi +index 1fc5f0bfa..a8851e8bd 100644 +--- a/gcc/doc/install.texi ++++ b/gcc/doc/install.texi +@@ -1353,6 +1353,10 @@ Multiple @var{option}s may appear consecutively while @var{arch} may only + appear in the beginning or be omitted (which means @option{-march=abi-default} + is applied when building the libraries). + ++@item --with-strict-align-lib ++On LoongArch targets, build all enabled multilibs with @option{-mstrict-align} ++(Not enabled by default). ++ + @item --with-multilib-generator=@var{config} + Specify what multilibs to build. @var{config} is a semicolon separated list of + values, possibly consisting of a single value. Currently only implemented +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-adjust-the-default-of-mexplicit-relocs-by-.patch
Added
@@ -0,0 +1,149 @@ +From aa10a2949c86e46b7952acbb58599e9bfdeabdfb Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Tue, 26 Jul 2022 21:46:20 +0800 +Subject: PATCH 006/124 LoongArch: adjust the default of -mexplicit-relocs by + checking gas feature + +The assembly produced with -mexplicit-relocs is not supported by gas <= +2.39. Check if the assembler supports explicit relocations and set the +default accordingly. + +gcc/ChangeLog: + + * configure.ac (HAVE_AS_EXPLICIT_RELOCS): Define to 1 if the + assembler supports explicit relocation for LoongArch. + * configure: Regenerate. + * config/loongarch/loongarch-opts.h (HAVE_AS_EXPLICIT_RELOCS): + Define to 0 if not defined. + * config/loongarch/genopts/loongarch.opt.in + (TARGET_EXPLICIT_RELOCS): Default to HAVE_AS_EXPLICIT_RELOCS. + * config/loongarch/loongarch.opt: Regenerate. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/genopts/loongarch.opt.in | 2 +- + gcc/config/loongarch/loongarch-opts.h | 4 +++ + gcc/config/loongarch/loongarch.opt | 2 +- + gcc/configure | 33 ++++++++++++++++++- + gcc/configure.ac | 7 +++- + 5 files changed, 44 insertions(+), 4 deletions(-) + +diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in +index 6f3950093..a571b6b75 100644 +--- a/gcc/config/loongarch/genopts/loongarch.opt.in ++++ b/gcc/config/loongarch/genopts/loongarch.opt.in +@@ -155,7 +155,7 @@ Target Joined RejectNegative UInteger Var(loongarch_max_inline_memcpy_size) Init + -mmax-inline-memcpy-size=SIZE Set the max size of memcpy to inline, default is 1024. + + mexplicit-relocs +-Target Var(TARGET_EXPLICIT_RELOCS) Init(1) ++Target Var(TARGET_EXPLICIT_RELOCS) Init(HAVE_AS_EXPLICIT_RELOCS) + Use %reloc() assembly operators. + + ; The code model option names for -mcmodel. +diff --git a/gcc/config/loongarch/loongarch-opts.h b/gcc/config/loongarch/loongarch-opts.h +index eaa6fc074..da24ecd2b 100644 +--- a/gcc/config/loongarch/loongarch-opts.h ++++ b/gcc/config/loongarch/loongarch-opts.h +@@ -87,4 +87,8 @@ loongarch_config_target (struct loongarch_target *target, + while -mno-memcpy imposes a global constraint. */ + #define TARGET_DO_OPTIMIZE_BLOCK_MOVE_P loongarch_do_optimize_block_move_p() + ++#ifndef HAVE_AS_EXPLICIT_RELOCS ++#define HAVE_AS_EXPLICIT_RELOCS 0 ++#endif ++ + #endif /* LOONGARCH_OPTS_H */ +diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt +index 7a8c5b444..9df7e1872 100644 +--- a/gcc/config/loongarch/loongarch.opt ++++ b/gcc/config/loongarch/loongarch.opt +@@ -162,7 +162,7 @@ Target Joined RejectNegative UInteger Var(loongarch_max_inline_memcpy_size) Init + -mmax-inline-memcpy-size=SIZE Set the max size of memcpy to inline, default is 1024. + + mexplicit-relocs +-Target Var(TARGET_EXPLICIT_RELOCS) Init(1) ++Target Var(TARGET_EXPLICIT_RELOCS) Init(HAVE_AS_EXPLICIT_RELOCS) + Use %reloc() assembly operators. + + ; The code model option names for -mcmodel. +diff --git a/gcc/configure b/gcc/configure +index 98bbf0f85..840eddc7c 100755 +--- a/gcc/configure ++++ b/gcc/configure +@@ -28792,7 +28792,7 @@ $as_echo "#define HAVE_AS_MARCH_ZIFENCEI 1" >>confdefs.h + fi + + ;; +- loongarch*-*-*) ++ loongarch*-*-*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for .dtprelword support" >&5 + $as_echo_n "checking assembler for .dtprelword support... " >&6; } + if ${gcc_cv_as_loongarch_dtprelword+:} false; then : +@@ -28828,6 +28828,37 @@ if test $gcc_cv_as_loongarch_dtprelword != yes; then + $as_echo "#define HAVE_AS_DTPRELWORD 1" >>confdefs.h + + fi ++ { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for explicit relocation support" >&5 ++$as_echo_n "checking assembler for explicit relocation support... " >&6; } ++if ${gcc_cv_as_loongarch_explicit_relocs+:} false; then : ++ $as_echo_n "(cached) " >&6 ++else ++ gcc_cv_as_loongarch_explicit_relocs=no ++ if test x$gcc_cv_as != x; then ++ $as_echo 'a:pcalau12i $t0,%pc_hi20(a)' > conftest.s ++ if { ac_try='$gcc_cv_as $gcc_cv_as_flags -o conftest.o conftest.s >&5' ++ { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 ++ test $ac_status = 0; }; } ++ then ++ gcc_cv_as_loongarch_explicit_relocs=yes ++ else ++ echo "configure: failed program was" >&5 ++ cat conftest.s >&5 ++ fi ++ rm -f conftest.o conftest.s ++ fi ++fi ++{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_loongarch_explicit_relocs" >&5 ++$as_echo "$gcc_cv_as_loongarch_explicit_relocs" >&6; } ++if test $gcc_cv_as_loongarch_explicit_relocs = yes; then ++ ++$as_echo "#define HAVE_AS_EXPLICIT_RELOCS 1" >>confdefs.h ++ ++fi ++ + ;; + s390*-*-*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for .gnu_attribute support" >&5 +diff --git a/gcc/configure.ac b/gcc/configure.ac +index c74f4b555..975c852c6 100644 +--- a/gcc/configure.ac ++++ b/gcc/configure.ac +@@ -5309,7 +5309,7 @@ configured with --enable-newlib-nano-formatted-io.) + AC_DEFINE(HAVE_AS_MARCH_ZIFENCEI, 1, + Define if the assembler understands -march=rv*_zifencei.)) + ;; +- loongarch*-*-*) ++ loongarch*-*-*) + gcc_GAS_CHECK_FEATURE(.dtprelword support, + gcc_cv_as_loongarch_dtprelword, 2,18,0,, + .section .tdata,"awT",@progbits +@@ -5319,6 +5319,11 @@ x: + .dtprelword x+0x8000,, + AC_DEFINE(HAVE_AS_DTPRELWORD, 1, + Define if your assembler supports .dtprelword.)) ++ gcc_GAS_CHECK_FEATURE(explicit relocation support, ++ gcc_cv_as_loongarch_explicit_relocs,, ++ a:pcalau12i $t0,%pc_hi20(a),, ++ AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1, ++ Define if your assembler supports explicit relocation.)) + ;; + s390*-*-*) + gcc_GAS_CHECK_FEATURE(.gnu_attribute support, +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-define-preprocessing-macros-__loongarch_-a.patch
Added
@@ -0,0 +1,42 @@ +From 41b01fb34126d8b40635af1847b21716f62e5388 Mon Sep 17 00:00:00 2001 +From: Yang Yujie <yangyujie@loongson.cn> +Date: Mon, 28 Aug 2023 09:32:16 +0800 +Subject: PATCH 059/124 LoongArch: define preprocessing macros + "__loongarch_{arch,tune}" + +These are exported according to the LoongArch Toolchain Conventions1 +as a replacement of the obsolete "_LOONGARCH_{ARCH,TUNE}" macros, +which are expanded to strings representing the actual architecture +and microarchitecture of the target. + +1 currently relased at https://github.com/loongson/LoongArch-Documentation + /blob/main/docs/LoongArch-toolchain-conventions-EN.adoc + +gcc/ChangeLog: + + * config/loongarch/loongarch-c.cc: Export macros + "__loongarch_{arch,tune}" in the preprocessor. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-c.cc | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/gcc/config/loongarch/loongarch-c.cc b/gcc/config/loongarch/loongarch-c.cc +index 2cf84eec7..c9b11a042 100644 +--- a/gcc/config/loongarch/loongarch-c.cc ++++ b/gcc/config/loongarch/loongarch-c.cc +@@ -64,6 +64,9 @@ loongarch_cpu_cpp_builtins (cpp_reader *pfile) + LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_ARCH", la_target.cpu_arch); + LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_TUNE", la_target.cpu_tune); + ++ LARCH_CPP_SET_PROCESSOR ("__loongarch_arch", la_target.cpu_arch); ++ LARCH_CPP_SET_PROCESSOR ("__loongarch_tune", la_target.cpu_tune); ++ + /* Base architecture / ABI. */ + if (TARGET_64BIT) + { +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-document-m-no-explicit-relocs.patch
Added
@@ -0,0 +1,43 @@ +From 3742550e00bf0401ead01cde64fc1571ffa075fc Mon Sep 17 00:00:00 2001 +From: WANG Xuerui <i@xen0n.name> +Date: Wed, 27 Jul 2022 15:01:17 +0800 +Subject: PATCH 007/124 LoongArch: document -mno-explicit-relocs + +gcc/ChangeLog: + + * doc/invoke.texi: Document -mno-explicit-relocs for + LoongArch. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/doc/invoke.texi | 13 +++++++++++++ + 1 file changed, 13 insertions(+) + +diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi +index 2b376e0e9..1de2b2bd4 100644 +--- a/gcc/doc/invoke.texi ++++ b/gcc/doc/invoke.texi +@@ -24663,6 +24663,19 @@ global symbol: The data got table must be within +/-8EiB addressing space. + @end itemize + @end table + The default code model is @code{normal}. ++ ++@item -mexplicit-relocs ++@itemx -mno-explicit-relocs ++@opindex mexplicit-relocs ++@opindex mno-explicit-relocs ++Use or do not use assembler relocation operators when dealing with symbolic ++addresses. The alternative is to use assembler macros instead, which may ++limit optimization. The default value for the option is determined during ++GCC build-time by detecting corresponding assembler support: ++@code{-mexplicit-relocs} if said support is present, ++@code{-mno-explicit-relocs} otherwise. This option is mostly useful for ++debugging, or interoperation with assemblers different from the build-time ++one. + @end table + + @node M32C Options +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-fix-error-building.patch
Added
@@ -0,0 +1,183 @@ +diff --git a/gcc/config/loongarch/loongarch-builtins.cc b/gcc/config/loongarch/loongarch-builtins.cc +index a4a7dbec9..2d9743d86 100644 +--- a/gcc/config/loongarch/loongarch-builtins.cc ++++ b/gcc/config/loongarch/loongarch-builtins.cc +@@ -2440,11 +2440,6 @@ loongarch_init_builtins (void) + unsigned int i; + tree type; + +- /* Register the type float128_type_node as a built-in type and +- give it an alias "__float128". */ +- (*lang_hooks.types.register_builtin_type) (float128_type_node, +- "__float128"); +- + /* Iterate through all of the bdesc arrays, initializing all of the + builtin functions. */ + for (i = 0; i < ARRAY_SIZE (loongarch_builtins); i++) +diff --git a/gcc/config/loongarch/loongarch-c.cc b/gcc/config/loongarch/loongarch-c.cc +index c9b11a042..76c8ea8db 100644 +--- a/gcc/config/loongarch/loongarch-c.cc ++++ b/gcc/config/loongarch/loongarch-c.cc +@@ -117,17 +117,6 @@ loongarch_cpu_cpp_builtins (cpp_reader *pfile) + builtin_define ("__loongarch_simd_width=256"); + } + +- /* Add support for FLOAT128_TYPE on the LoongArch architecture. */ +- builtin_define ("__FLOAT128_TYPE__"); +- +- /* Map the old _Float128 'q' builtins into the new 'f128' builtins. */ +- builtin_define ("__builtin_fabsq=__builtin_fabsf128"); +- builtin_define ("__builtin_copysignq=__builtin_copysignf128"); +- builtin_define ("__builtin_nanq=__builtin_nanf128"); +- builtin_define ("__builtin_nansq=__builtin_nansf128"); +- builtin_define ("__builtin_infq=__builtin_inff128"); +- builtin_define ("__builtin_huge_valq=__builtin_huge_valf128"); +- + /* Native Data Sizes. */ + builtin_define_with_int_value ("_LOONGARCH_SZINT", INT_TYPE_SIZE); + builtin_define_with_int_value ("_LOONGARCH_SZLONG", LONG_TYPE_SIZE); +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index baa9831aa..ae074edbd 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -9712,13 +9712,10 @@ expand_perm_const_2_end: + /* Implement TARGET_VECTORIZE_VEC_PERM_CONST. */ + + static bool +-loongarch_vectorize_vec_perm_const (machine_mode vmode, machine_mode op_mode, ++loongarch_vectorize_vec_perm_const (machine_mode vmode, + rtx target, rtx op0, rtx op1, + const vec_perm_indices &sel) + { +- if (vmode != op_mode) +- return false; +- + struct expand_vec_perm_d d; + int i, nelt, which; + unsigned char orig_permMAX_VECT_LEN; +diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi +index bb19d0f27..1d1bac255 100644 +--- a/gcc/doc/extend.texi ++++ b/gcc/doc/extend.texi +@@ -1085,10 +1085,10 @@ types. + As an extension, GNU C and GNU C++ support additional floating + types, which are not supported by all targets. + @itemize @bullet +-@item @code{__float128} is available on i386, x86_64, IA-64, LoongArch +-and hppa HP-UX, as well as on PowerPC GNU/Linux targets that enable ++@item @code{__float128} is available on i386, x86_64, IA-64, and ++hppa HP-UX, as well as on PowerPC GNU/Linux targets that enable + the vector scalar (VSX) instruction set. @code{__float128} supports +-the 128-bit floating type. On i386, x86_64, PowerPC, LoongArch and IA-64, ++the 128-bit floating type. On i386, x86_64, PowerPC, and IA-64 + other than HP-UX, @code{__float128} is an alias for @code{_Float128}. + On hppa and IA-64 HP-UX, @code{__float128} is an alias for @code{long + double}. +@@ -16257,20 +16257,6 @@ function you need to include @code{larchintrin.h}. + void __break (imm0_32767) + @end smallexample + +-Additional built-in functions are available for LoongArch family +-processors to efficiently use 128-bit floating-point (__float128) +-values. +- +-The following are the basic built-in functions supported. +-@smallexample +-__float128 __builtin_fabsq (__float128); +-__float128 __builtin_copysignq (__float128, __float128); +-__float128 __builtin_infq (void); +-__float128 __builtin_huge_valq (void); +-__float128 __builtin_nanq (void); +-__float128 __builtin_nansq (void); +-@end smallexample +- + @node MIPS DSP Built-in Functions + @subsection MIPS DSP Built-in Functions + +diff --git a/gcc/testsuite/gcc.target/loongarch/math-float-128.c b/gcc/testsuite/gcc.target/loongarch/math-float-128.c +deleted file mode 100644 +index 387566a57..000000000 +--- a/gcc/testsuite/gcc.target/loongarch/math-float-128.c ++++ /dev/null +@@ -1,81 +0,0 @@ +-/* { dg-do compile } */ +-/* { dg-options " -march=loongarch64 -O2 " } */ +-/* { dg-final { scan-assembler-not "my_fabsq2:.*\\bl\t%plt\\(__builtin_fabsq\\).*my_fabsq2" } } */ +-/* { dg-final { scan-assembler-not "my_copysignq2:.*\\bl\t%plt\\(__builtin_copysignq\\).*my_copysignq2" } } */ +-/* { dg-final { scan-assembler-not "my_infq2:.*\\bl\t%plt\\(__builtin_infq\\).*my_infq2" } } */ +-/* { dg-final { scan-assembler-not "my_huge_valq2:.*\\bl\t%plt\\(__builtin_huge_valq\\).*my_huge_valq2" } } */ +-/* { dg-final { scan-assembler-not "my_nanq2:.*\\bl\t%plt\\(__builtin_nanq\\).*my_nanq2" } } */ +-/* { dg-final { scan-assembler-not "my_nansq2:.*\\bl\t%plt\\(__builtin_nansq\\).*my_nansq2" } } */ +- +-__float128 +-my_fabsq1 (__float128 a) +-{ +- return __builtin_fabsq (a); +-} +- +-_Float128 +-my_fabsq2 (_Float128 a) +-{ +- return __builtin_fabsq (a); +-} +- +-__float128 +-my_copysignq1 (__float128 a, __float128 b) +-{ +- return __builtin_copysignq (a, b); +-} +- +-_Float128 +-my_copysignq2 (_Float128 a, _Float128 b) +-{ +- return __builtin_copysignq (a, b); +-} +- +-__float128 +-my_infq1 (void) +-{ +- return __builtin_infq (); +-} +- +-_Float128 +-my_infq2 (void) +-{ +- return __builtin_infq (); +-} +- +-__float128 +-my_huge_valq1 (void) +-{ +- return __builtin_huge_valq (); +-} +- +-_Float128 +-my_huge_valq2 (void) +-{ +- return __builtin_huge_valq (); +-} +- +-__float128 +-my_nanq1 (void) +-{ +- return __builtin_nanq (""); +-} +- +-_Float128 +-my_nanq2 (void) +-{ +- return __builtin_nanq (""); +-} +- +-__float128 +-my_nansq1 (void) +-{ +- return __builtin_nansq (""); +-} +- +-_Float128 +-my_nansq2 (void) +-{ +- return __builtin_nansq (""); +-} +-
View file
_service:tar_scm:LoongArch-fix-signed-overflow-in-loongarch_emit_int_.patch
Added
@@ -0,0 +1,43 @@ +From 15f1e94ddd7128f407ada43fd9e4b26d4a8bba8d Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Fri, 4 Nov 2022 01:35:25 +0800 +Subject: PATCH 026/124 LoongArch: fix signed overflow in + loongarch_emit_int_compare + +Signed overflow is an undefined behavior, so we need to prevent it from +happening, instead of "checking" the result. + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_emit_int_compare): + Avoid signed overflow. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.cc | 7 +++++-- + 1 file changed, 5 insertions(+), 2 deletions(-) + +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index e9ba3374e..d552b162a 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -4177,10 +4177,13 @@ loongarch_emit_int_compare (enum rtx_code *code, rtx *op0, rtx *op1) + if (!increment && !decrement) + continue; + ++ if ((increment && rhs == HOST_WIDE_INT_MAX) ++ || (decrement && rhs == HOST_WIDE_INT_MIN)) ++ break; ++ + new_rhs = rhs + (increment ? 1 : -1); + if (loongarch_integer_cost (new_rhs) +- < loongarch_integer_cost (rhs) +- && (rhs < 0) == (new_rhs < 0)) ++ < loongarch_integer_cost (rhs)) + { + *op1 = GEN_INT (new_rhs); + *code = mag_comparisonsiincrement; +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-implement-count_-leading-trailing-_zeros.patch
Added
@@ -0,0 +1,50 @@ +From ad6541a22dd909a04d745b42c8da5e04733efec4 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 12 Oct 2022 22:06:07 +0800 +Subject: PATCH 023/124 LoongArch: implement count_{leading,trailing}_zeros + +LoongArch always support clz and ctz instructions, so we can always use +__builtin_{clz,ctz} for count_{leading,trailing}_zeros. This improves +the code of libgcc, and also benefits Glibc once we merge longlong.h +there. + +Bootstrapped and regtested on loongarch64-linux-gnu. + +include/ChangeLog: + + * longlong.h __loongarch__ (count_leading_zeros): Define. + __loongarch__ (count_trailing_zeros): Likewise. + __loongarch__ (COUNT_LEADING_ZEROS_0): Likewise. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + include/longlong.h | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/include/longlong.h b/include/longlong.h +index 64a7b10f9..c3a6f1e7e 100644 +--- a/include/longlong.h ++++ b/include/longlong.h +@@ -593,6 +593,18 @@ extern UDItype __umulsidi3 (USItype, USItype); + #define UMUL_TIME 14 + #endif + ++#ifdef __loongarch__ ++# if W_TYPE_SIZE == 32 ++# define count_leading_zeros(count, x) ((count) = __builtin_clz (x)) ++# define count_trailing_zeros(count, x) ((count) = __builtin_ctz (x)) ++# define COUNT_LEADING_ZEROS_0 32 ++# elif W_TYPE_SIZE == 64 ++# define count_leading_zeros(count, x) ((count) = __builtin_clzll (x)) ++# define count_trailing_zeros(count, x) ((count) = __builtin_ctzll (x)) ++# define COUNT_LEADING_ZEROS_0 64 ++# endif ++#endif ++ + #if defined (__M32R__) && W_TYPE_SIZE == 32 + #define add_ssaaaa(sh, sl, ah, al, bh, bl) \ + /* The cmp clears the condition bit. */ \ +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-improved-target-configuration-interface.patch
Added
@@ -0,0 +1,3024 @@ +From b980a32eabcbd34e8f8e6a245dbba1898256555e Mon Sep 17 00:00:00 2001 +From: Yang Yujie <yangyujie@loongson.cn> +Date: Wed, 23 Aug 2023 15:16:21 +0800 +Subject: PATCH 058/124 LoongArch: improved target configuration interface + +The configure script and the GCC driver are updated so that +it is easier to customize and control GCC builds for targeting +different LoongArch implementations. + +* Make --with-abi obsolete, since it might cause different default ABI + under the same target triplet, which is undesirable. The default ABI + is now purely decided by the target triplet. + +* Support options for LoongArch SIMD extensions: + new configure options --with-simd={none,lsx,lasx}; + new compiler option -msimd={none,lsx,lasx}; + new driver options -mno-lasx. + +* Enforce the priority of configuration paths (for <parm>={fpu,tune,simd}): + -m<parm> > -march-implied > --with-<parm> > --with-arch-implied. + +* Allow the user to control the compiler options used when building + GCC libraries for each multilib variant via --with-multilib-list + and --with-multilib-default. This could become more useful when + we have 32-bit support later. + + Example 1: the following configure option + --with-multilib-list=lp64d/la464/mno-strict-align/msimd=lsx,lp64s/mfpu=32 + | | | | + -mabi=ABI -march=ARCH a list of other options + (mandatory) (optional) (optional) + + builds two sets of libraries: + 1. lp64d/base ABI (built with "-march=la464 -mno-strict-align -msimd=lsx") + 2. lp64s/base ABI (built with "-march=abi-default -mfpu=32") + + Example 2: the following 3 configure options + + --with-arch=loongarch64 + --with-multilib-list=lp64d,lp64f,lp64s/la464 + --with-multilib-default=fixed/mno-strict-align/mfpu=64 + | | | + -march=ARCH a list of other options + (optional) (optional) + + is equivalent to (in terms of building libraries): + + --with-multilib-list=\ + lp64d/loongarch64/mno-strict-align/mfpu=64,\ + lp64f/loongarch64/mno-strict-align/mfpu=64,\ + lp64s/la464 + + Note: + 1. the GCC driver and compiler proper does not support + "-march=fixed". "fixed" that appear here acts as a placeholder for + "use whatever ARCH in --with-arch=ARCH" (or the default value + of --with-arch=ARCH if --with-arch is not explicitly configured). + + 2. if the ARCH part is omitted, "-march=abi-default" + is used for building all library variants, which + practically means enabling the minimal ISA features + that can support the given ABI. + +ChangeLog: + + * config-ml.in: Do not build the multilib library variant + that is duplicate with the toplevel one. + +gcc/ChangeLog: + + * config.gcc: Make --with-abi= obsolete, decide the default ABI + with target triplet. Allow specifying multilib library build + options with --with-multilib-list and --with-multilib-default. + * config/loongarch/t-linux: Likewise. + * config/loongarch/genopts/loongarch-strings: Likewise. + * config/loongarch/loongarch-str.h: Likewise. + * doc/install.texi: Likewise. + * config/loongarch/genopts/loongarch.opt.in: Introduce + -mno-lasx options. Only process -m*-float and + -mno-lasx in the GCC driver. + * config/loongarch/loongarch.opt: Likewise. + * config/loongarch/la464.md: Likewise. + * config/loongarch/loongarch-c.cc: Likewise. + * config/loongarch/loongarch-cpu.cc: Likewise. + * config/loongarch/loongarch-cpu.h: Likewise. + * config/loongarch/loongarch-def.c: Likewise. + * config/loongarch/loongarch-def.h: Likewise. + * config/loongarch/loongarch-driver.cc: Likewise. + * config/loongarch/loongarch-driver.h: Likewise. + * config/loongarch/loongarch-opts.cc: Likewise. + * config/loongarch/loongarch-opts.h: Likewise. + * config/loongarch/loongarch.cc: Likewise. + * doc/invoke.texi: Likewise. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + config-ml.in | 10 + + gcc/config.gcc | 379 ++++++++++-------- + .../loongarch/genopts/loongarch-strings | 8 +- + gcc/config/loongarch/genopts/loongarch.opt.in | 62 +-- + gcc/config/loongarch/la464.md | 32 +- + gcc/config/loongarch/loongarch-c.cc | 19 +- + gcc/config/loongarch/loongarch-cpu.cc | 263 +++++++----- + gcc/config/loongarch/loongarch-cpu.h | 3 +- + gcc/config/loongarch/loongarch-def.c | 67 ++-- + gcc/config/loongarch/loongarch-def.h | 57 +-- + gcc/config/loongarch/loongarch-driver.cc | 208 +++++----- + gcc/config/loongarch/loongarch-driver.h | 40 +- + gcc/config/loongarch/loongarch-opts.cc | 372 ++++++++++++----- + gcc/config/loongarch/loongarch-opts.h | 59 +-- + gcc/config/loongarch/loongarch-str.h | 7 +- + gcc/config/loongarch/loongarch.cc | 87 ++-- + gcc/config/loongarch/loongarch.opt | 60 ++- + gcc/config/loongarch/t-linux | 32 +- + gcc/doc/install.texi | 52 ++- + 19 files changed, 1136 insertions(+), 681 deletions(-) + +diff --git a/config-ml.in b/config-ml.in +index 68854a4f1..ad0db0781 100644 +--- a/config-ml.in ++++ b/config-ml.in +@@ -301,6 +301,16 @@ arm-*-*) + done + fi + ;; ++loongarch*-*) ++ old_multidirs="${multidirs}" ++ multidirs="" ++ for x in ${old_multidirs}; do ++ case "$x" in ++ `${CC-gcc} --print-multi-directory`) : ;; ++ *) multidirs="${multidirs} ${x}" ;; ++ esac ++ done ++ ;; + m68*-*-*) + if x$enable_softfloat = xno + then +diff --git a/gcc/config.gcc b/gcc/config.gcc +index 5c378c698..62525c296 100644 +--- a/gcc/config.gcc ++++ b/gcc/config.gcc +@@ -4965,43 +4965,46 @@ case "${target}" in + esac + ;; + +- loongarch*-*-*) +- supported_defaults="abi arch tune fpu" ++ loongarch*-*) ++ supported_defaults="abi arch tune fpu simd multilib-default" + + # Local variables + unset \ +- abi_pattern abi_default \ +- abiext_pattern abiext_default \ +- arch_pattern arch_default \ +- fpu_pattern fpu_default \ +- tune_pattern tune_default \ +- triplet_os triplet_abi ++ abi_base abi_ext \ ++ arch_pattern arch_default \ ++ fpu_pattern fpu_default \ ++ triplet_os triplet_abi \ ++ strict_align_opt ++ ++ # --with-abi is now obsolete, emit a warning if given. ++ case ${with_abi} in ++ "") ;; ++ *) ++ echo "warning: --with-abi= is now obsolete," \ ++ "the default ABI is derived from your target" \ ++ "triplet ${target}" 1>&2 ++ ;; ++ esac + + # Infer ABI from the triplet. + case ${target} in +- loongarch64-*-*-*f64) +- abi_pattern="lp64d" +- ;; +- loongarch64-*-*-*f32) +- abi_pattern="lp64f" +- ;; +- loongarch64-*-*-*sf) +- abi_pattern="lp64s" +- ;; +- loongarch64-*-*-*) +- abi_pattern="lp64dfs" +- abi_default="lp64d" +- ;; ++ loongarch64-*f64) abi_base="lp64d"; abi_ext="base" ;; ++ loongarch64-*f32) abi_base="lp64f"; abi_ext="base" ;; ++ loongarch64-*sf) abi_base="lp64s"; abi_ext="base" ;; ++ loongarch64-*) abi_base="lp64d"; abi_ext="base" ;; + *) + echo "Unsupported target ${target}." 1>&2 + exit 1 + ;; + esac + +- abiext_pattern="*" +- abiext_default="base" +- + # Get the canonical triplet (multiarch specifier). ++ case ${abi_base},${abi_ext} in ++ lp64d,base) triplet_abi="";; ++ lp64f,base) triplet_abi="f32";; ++ lp64s,base) triplet_abi="sf";; ++ esac ++ + case ${target} in + *-linux-gnu*) triplet_os="linux-gnu";; + *-linux-musl*) triplet_os="linux-musl";; +@@ -5010,42 +5013,24 @@ case "${target}" in + exit 1 + ;; + esac ++ la_canonical_triplet="loongarch64-${triplet_os}${triplet_abi}" ++ + + # Perform initial sanity checks on --with-* options. + case ${with_arch} in +- "" | loongarch64 | la464) ;; # OK, append here. ++ "" | abi-default | loongarch64 | la464) ;; # OK, append here. + native) + if test x${host} != x${target}; then + echo "--with-arch=native is illegal for cross-compiler." 1>&2 + exit 1 + fi + ;; +- "") +- echo "Please set a default value for \${with_arch}" \ +- "according to your target triplet \"${target}\"." 1>&2 +- exit 1 +- ;; + *) + echo "Unknown arch in --with-arch=$with_arch" 1>&2 + exit 1 + ;; + esac + +- case ${with_abi} in +- "" | lp64d | lp64f | lp64s) ;; # OK, append here. +- *) +- echo "Unsupported ABI given in --with-abi=$with_abi" 1>&2 +- exit 1 +- ;; +- esac +- +- case ${with_abiext} in +- "" | base) ;; # OK, append here. +- *) +- echo "Unsupported ABI extention type $with_abiext" 1>&2 +- exit 1 +- ;; +- esac + + case ${with_fpu} in + "" | none | 32 | 64) ;; # OK, append here. +@@ -5059,73 +5044,41 @@ case "${target}" in + ;; + esac + +- +- # Set default value for with_abi. +- case ${with_abi} in +- "") +- if test x${abi_default} != x; then +- with_abi=${abi_default} +- else +- with_abi=${abi_pattern} +- fi +- ;; +- +- *) +- if echo "${with_abi}" | grep -E "^${abi_pattern}$" > /dev/null; then +- : # OK +- else +- echo "Incompatible options:" \ +- "--with-abi=${with_abi} and --target=${target}." 1>&2 ++ case ${with_simd} in ++ "" | none) ;; ++ lsx | lasx) # OK, append here. ++ case ${with_fpu} in ++ 64) ;; ++ "") with_fpu=64 ;; ++ *) ++ echo "--with-simd=${with_simd} conflicts with --with-fpu=${with_fpu}" 1>&2 + exit 1 +- fi +- ;; +- esac +- +- case ${with_abi} in +- "lp64d") triplet_abi="";; +- "lp64f") triplet_abi="f32";; +- "lp64s") triplet_abi="sf";; +- esac +- la_canonical_triplet="loongarch64-${triplet_os}${triplet_abi}" +- +- # Set default value for with_abiext (internal) +- case ${with_abiext} in +- "") +- if test x${abiext_default} != x; then +- with_abiext=${abiext_default} +- else +- with_abiext=${abiext_pattern} +- fi ++ ;; ++ esac + ;; + + *) +- if echo "${with_abiext}" | grep -E "^${abiext_pattern}$" > /dev/null; then +- : # OK +- else +- echo "The ABI extension type \"${with_abiext}\"" \ +- "is incompatible with --target=${target}." 1>&2 +- exit 1 +- fi +- ++ echo "Unknown SIMD extension in --with-simd=$with_simd" 1>&2 ++ exit 1 + ;; + esac + + # Infer ISA-related default options from the ABI: pass 1 +- case ${with_abi}/${with_abiext} in ++ case ${abi_base}/${abi_ext} in + lp64*/base) + # architectures that support lp64* ABI +- arch_pattern="native|loongarch64|la464" ++ arch_pattern="native|abi-default|loongarch64|la464" + # default architecture for lp64* ABI +- arch_default="loongarch64" ++ arch_default="abi-default" + ;; + *) +- echo "Unsupported ABI type ${with_abi}/${with_abiext}." 1>&2 ++ echo "Unsupported ABI type ${abi_base}/${abi_ext}." 1>&2 + exit 1 + ;; + esac + + # Infer ISA-related default options from the ABI: pass 2 +- case ${with_abi}/${with_abiext} in ++ case ${abi_base}/${abi_ext} in + lp64d/base) + fpu_pattern="64" + ;; +@@ -5138,7 +5091,7 @@ case "${target}" in + fpu_default="none" + ;; + *) +- echo "Unsupported ABI type ${with_abi}/${with_abiext}." 1>&2 ++ echo "Unsupported ABI type ${abi_base}/${abi_ext}." 1>&2 + exit 1 + ;; + esac +@@ -5157,7 +5110,7 @@ case "${target}" in + if echo "${with_arch}" | grep -E "^${arch_pattern}$" > /dev/null; then + : # OK + else +- echo "${with_abi}/${with_abiext} ABI cannot be implemented with" \ ++ echo "${abi_base}/${abi_ext} ABI cannot be implemented with" \ + "--with-arch=${with_arch}." 1>&2 + exit 1 + fi +@@ -5178,7 +5131,7 @@ case "${target}" in + if echo "${with_fpu}" | grep -E "^${fpu_pattern}$" > /dev/null; then + : # OK + else +- echo "${with_abi}/${with_abiext} ABI cannot be implemented with" \ ++ echo "${abi_base}/${abi_ext} ABI cannot be implemented with" \ + "--with-fpu=${with_fpu}." 1>&2 + exit 1 + fi +@@ -5186,32 +5139,19 @@ case "${target}" in + esac + + +- # Infer default with_tune from with_arch: pass 1 ++ # Check default with_tune configuration using with_arch. + case ${with_arch} in +- native) +- tune_pattern="*" +- tune_default="native" +- ;; + loongarch64) +- tune_pattern="loongarch64|la464" +- tune_default="la464" ++ tune_pattern="native|abi-default|loongarch64|la464" + ;; + *) + # By default, $with_tune == $with_arch +- tune_pattern="$with_arch" ++ tune_pattern="*" + ;; + esac + +- ## Set default value for with_tune. + case ${with_tune} in +- "") +- if test x${tune_default} != x; then +- with_tune=${tune_default} +- else +- with_tune=${tune_pattern} +- fi +- ;; +- ++ "") ;; # OK + *) + if echo "${with_tune}" | grep -E "^${tune_pattern}$" > /dev/null; then + : # OK +@@ -5223,13 +5163,53 @@ case "${target}" in + ;; + esac + ++ # Handle --with-multilib-default ++ if echo "${with_multilib_default}" \ ++ | grep -E -e ':space:' -e '//' -e '/$' -e '^/' > /dev/null 2>&1; then ++ echo "Invalid argument to --with-multilib-default." 1>&2 ++ exit 1 ++ fi ++ ++ if test x${with_multilib_default} = x; then ++ # Use -march=abi-default by default when building libraries. ++ with_multilib_default="/march=abi-default" ++ else ++ unset parse_state component ++ parse_state=arch ++ for component in $(echo "${with_multilib_default}" | tr '/' ' '); do ++ case ${parse_state},${component} in ++ arch,|arch,abi-default) ++ # ABI-default: use the ABI's default ARCH configuration for ++ # multilib library builds, unless otherwise specified ++ # in --with-multilib-list. ++ with_multilib_default="/march=abi-default" ;; ++ arch,fixed) ++ # Fixed: use the default gcc configuration for all multilib ++ # builds by default. ++ with_multilib_default="" ;; ++ arch,native|arch,loongarch64|arch,la464) # OK, append here. ++ with_multilib_default="/march=${component}" ;; ++ arch,*) ++ with_multilib_default="/march=abi-default" ++ with_multilib_default="${with_multilib_default}/${component}" ;; ++ opts,*) ++ with_multilib_default="${with_multilib_default}/${component}" ;; ++ esac ++ ++ if test x${parse_state} = xarch; then ++ parse_state=opt; ++ fi ++ done ++ unset parse_state component ++ fi ++ + # Handle --with-multilib-list. + if test x"${with_multilib_list}" = x \ + || test x"${with_multilib_list}" = xno \ + || test x"${with_multilib_list}" = xdefault \ + || test x"${enable_multilib}" != xyes; then + +- with_multilib_list="${with_abi}/${with_abiext}" ++ with_multilib_list="${abi_base}/${abi_ext}" + fi + + # Check if the configured default ABI combination is included in +@@ -5245,25 +5225,21 @@ case "${target}" in + # ${with_multilib_list} should not contain whitespaces, + # consecutive commas or slashes. + if echo "${with_multilib_list}" \ +- | grep -E -e ":space:" -e ',/,/' -e ',/$' -e '^,/' > /dev/null; then ++ | grep -E -e ":space:" -e ',/,/' -e ',/$' -e '^,/' > /dev/null 2>&1; then + echo "Invalid argument to --with-multilib-list." 1>&2 + exit 1 + fi + +- unset component idx elem_abi_base elem_abi_ext elem_tmp ++ unset component elem_abi_base elem_abi_ext elem_tmp parse_state all_abis + for elem in $(echo "${with_multilib_list}" | tr ',' ' '); do +- idx=0 +- while true; do +- idx=$((idx + 1)) +- component=$(echo "${elem}" | awk -F'/' '{print $'"${idx}"'}') +- +- case ${idx} in +- 1) +- # Component 1: Base ABI type ++ unset elem_abi_base elem_abi_ext ++ parse_state="abi-base" ++ ++ for component in $(echo "${elem}" | tr '/' ' '); do ++ if test x${parse_state} = x"abi-base"; then ++ # Base ABI type + case ${component} in +- lp64d) elem_tmp="ABI_BASE_LP64D,";; +- lp64f) elem_tmp="ABI_BASE_LP64F,";; +- lp64s) elem_tmp="ABI_BASE_LP64S,";; ++ lp64d | lp64f | lp64s) elem_tmp="ABI_BASE_$(tr a-z A-Z <<< ${component}),";; + *) + echo "Unknown base ABI \"${component}\" in --with-multilib-list." 1>&2 + exit 1 +@@ -5272,57 +5248,111 @@ case "${target}" in + loongarch_multilib_list_c="${loongarch_multilib_list_c}${elem_tmp}" + loongarch_multilib_list_make="${loongarch_multilib_list_make}mabi=${component}" + elem_abi_base="${component}" +- ;; + +- 2) +- # Component 2: ABI extension type ++ parse_state="abi-ext" ++ continue ++ fi ++ ++ if test x${parse_state} = x"abi-ext"; then ++ # ABI extension type + case ${component} in +- "" | base) +- component="base" +- elem_tmp="ABI_EXT_BASE," +- ;; +- *) +- echo "Unknown ABI extension \"${component}\" in --with-multilib-list." 1>&2 +- exit 1 ++ base) ++ elem_abi_ext="base" ++ loongarch_multilib_list_c="${loongarch_multilib_list_c}ABI_EXT_BASE," ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}" # Add nothing for now. ++ parse_state="arch" ++ continue; + ;; + esac +- loongarch_multilib_list_c="${loongarch_multilib_list_c}${elem_tmp}" ++ ++ # The default ABI extension is "base" if unspecified. ++ elem_abi_ext="base" ++ loongarch_multilib_list_c="${loongarch_multilib_list_c}ABI_EXT_BASE," + loongarch_multilib_list_make="${loongarch_multilib_list_make}" # Add nothing for now. +- elem_abi_ext="${component}" +- ;; ++ parse_state="arch" ++ fi + +- *) +- # Component 3 and on: optional stuff ++ if test x${parse_state} = x"arch"; then ++ # -march option + case ${component} in +- "") +- # End of component list. +- break ++ native | abi-default | loongarch64 | la464) # OK, append here. ++ # Append -march spec for each multilib variant. ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}/march=${component}" ++ parse_state="opts" ++ continue ++ ;; ++ ++ default) ++ # "/default" is equivalent to --with-multilib-default=fixed ++ parse_state="opts" ++ continue + ;; ++ esac ++ ++ # If ARCH is unspecified for this multilib variant, use ${with_multllib_default}. ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}${with_multilib_default}" ++ parse_state="opts" ++ fi ++ ++ if test x${parse_state} = x"opts"; then ++ # Other compiler options for building libraries. ++ # (no static sanity check performed) ++ case ${component} in + *) +- echo "Unknown ABI \"${elem}\" in --with-multilib-list." 1>&2 +- exit 1 ++ # Append other components as additional build options ++ # (without the prepending dash). ++ # Their validity should be examined by the compiler. ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}/${component}" + ;; + esac +- ;; +- esac ++ fi + done + +- if test x${elem_abi_base} = x${with_abi} \ +- && test x${elem_abi_ext} = x${with_abiext}; then ++ case ${parse_state} in ++ "abi-ext") ++ elem_abi_ext="base" ++ loongarch_multilib_list_c="${loongarch_multilib_list_c}ABI_EXT_BASE," ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}" # Add nothing for now. ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}${with_multilib_default}" ++ ;; ++ "arch") ++ # If ARCH is unspecified for this multilib variant, use ${with_multllib_default}. ++ loongarch_multilib_list_make="${loongarch_multilib_list_make}${with_multilib_default}" ++ ;; ++ "opts") ++ : ++ ;; ++ esac ++ ++ # Check for repeated configuration of the same multilib variant. ++ if echo "${elem_abi_base}/${elem_abi_ext}" \ ++ | grep -E "^(${all_abis%|})$" >/dev/null 2>&1; then ++ echo "Repeated multilib config of \"${elem_abi_base}/${elem_abi_ext}\" in --with-multilib-list." ++ exit 1 ++ fi ++ all_abis="${all_abis}${elem_abi_base}/${elem_abi_ext}|" ++ ++ ++ # Check if the default ABI configuration of the GCC binary ++ # is included in the enabled multilib variants. ++ if test x${elem_abi_base} = x${abi_base} \ ++ && test x${elem_abi_ext} = x${abi_ext}; then + loongarch_multilib_list_sane=yes + fi + loongarch_multilib_list_make="${loongarch_multilib_list_make}," + done ++ unset component elem_abi_base elem_abi_ext elem_tmp parse_state all_abis ++ + + # Check if the default ABI combination is in the default list. + if test x${loongarch_multilib_list_sane} = xno; then +- if test x${with_abiext} = xbase; then +- with_abiext="" ++ if test x${abi_ext} = xbase; then ++ abi_ext="" + else +- with_abiext="/${with_abiext}" ++ abi_ext="/${abi_ext}" + fi + +- echo "Default ABI combination (${with_abi}${with_abiext})" \ ++ echo "Default ABI combination (${abi_base}${abi_ext})" \ + "not found in --with-multilib-list." 1>&2 + exit 1 + fi +@@ -5783,34 +5813,37 @@ case ${target} in + + # Let --with- flags initialize the enum variables from loongarch.opt. + # See macro definitions from loongarch-opts.h and loongarch-cpu.h. +- case ${with_arch} in +- native) tm_defines="${tm_defines} DEFAULT_CPU_ARCH=CPU_NATIVE" ;; +- la464) tm_defines="${tm_defines} DEFAULT_CPU_ARCH=CPU_LA464" ;; +- loongarch64) tm_defines="${tm_defines} DEFAULT_CPU_ARCH=CPU_LOONGARCH64" ;; +- esac + +- case ${with_tune} in +- native) tm_defines="${tm_defines} DEFAULT_CPU_TUNE=CPU_NATIVE" ;; +- la464) tm_defines="${tm_defines} DEFAULT_CPU_TUNE=CPU_LA464" ;; +- loongarch64) tm_defines="${tm_defines} DEFAULT_CPU_TUNE=CPU_LOONGARCH64" ;; +- esac ++ # Architecture ++ tm_defines="${tm_defines} DEFAULT_CPU_ARCH=CPU_$(echo ${with_arch} | tr a-z- A-Z_)" + +- case ${with_abi} in +- lp64d) tm_defines="${tm_defines} DEFAULT_ABI_BASE=ABI_BASE_LP64D" ;; +- lp64f) tm_defines="${tm_defines} DEFAULT_ABI_BASE=ABI_BASE_LP64F" ;; +- lp64s) tm_defines="${tm_defines} DEFAULT_ABI_BASE=ABI_BASE_LP64S" ;; +- esac ++ # Base ABI type ++ tm_defines="${tm_defines} DEFAULT_ABI_BASE=ABI_BASE_$(echo ${abi_base} | tr a-z- A-Z_)" + +- case ${with_abiext} in ++ # ABI Extension ++ case ${abi_ext} in + base) tm_defines="${tm_defines} DEFAULT_ABI_EXT=ABI_EXT_BASE" ;; + esac + ++ # Microarchitecture ++ if test x${with_tune} != x; then ++ tm_defines="${tm_defines} DEFAULT_CPU_TUNE=CPU_$(echo ${with_tune} | tr a-z- A-Z_)" ++ fi ++ ++ # FPU adjustment + case ${with_fpu} in +- none) tm_defines="$tm_defines DEFAULT_ISA_EXT_FPU=ISA_EXT_NOFPU" ;; ++ none) tm_defines="$tm_defines DEFAULT_ISA_EXT_FPU=ISA_EXT_NONE" ;; + 32) tm_defines="$tm_defines DEFAULT_ISA_EXT_FPU=ISA_EXT_FPU32" ;; + 64) tm_defines="$tm_defines DEFAULT_ISA_EXT_FPU=ISA_EXT_FPU64" ;; + esac + ++ # SIMD extensions ++ case ${with_simd} in ++ none) tm_defines="$tm_defines DEFAULT_ISA_EXT_SIMD=ISA_EXT_NONE" ;; ++ lsx) tm_defines="$tm_defines DEFAULT_ISA_EXT_SIMD=ISA_EXT_SIMD_LSX" ;; ++ lasx) tm_defines="$tm_defines DEFAULT_ISA_EXT_SIMD=ISA_EXT_SIMD_LASX" ;; ++ esac ++ + tmake_file="loongarch/t-loongarch $tmake_file" + ;; + +diff --git a/gcc/config/loongarch/genopts/loongarch-strings b/gcc/config/loongarch/genopts/loongarch-strings +index 44ebb7ab1..21245f52a 100644 +--- a/gcc/config/loongarch/genopts/loongarch-strings ++++ b/gcc/config/loongarch/genopts/loongarch-strings +@@ -23,6 +23,7 @@ OPTSTR_ARCH arch + OPTSTR_TUNE tune + + STR_CPU_NATIVE native ++STR_CPU_ABI_DEFAULT abi-default + STR_CPU_LOONGARCH64 loongarch64 + STR_CPU_LA464 la464 + +@@ -31,7 +32,7 @@ STR_ISA_BASE_LA64V100 la64 + + # -mfpu + OPTSTR_ISA_EXT_FPU fpu +-STR_ISA_EXT_NOFPU none ++STR_NONE none + STR_ISA_EXT_FPU0 0 + STR_ISA_EXT_FPU32 32 + STR_ISA_EXT_FPU64 64 +@@ -40,6 +41,11 @@ OPTSTR_SOFT_FLOAT soft-float + OPTSTR_SINGLE_FLOAT single-float + OPTSTR_DOUBLE_FLOAT double-float + ++# SIMD extensions ++OPTSTR_ISA_EXT_SIMD simd ++STR_ISA_EXT_LSX lsx ++STR_ISA_EXT_LASX lasx ++ + # -mabi= + OPTSTR_ABI_BASE abi + STR_ABI_BASE_LP64D lp64d +diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in +index e10618777..c6e337d05 100644 +--- a/gcc/config/loongarch/genopts/loongarch.opt.in ++++ b/gcc/config/loongarch/genopts/loongarch.opt.in +@@ -17,22 +17,12 @@ + ; <http://www.gnu.org/licenses/>. + ; + +-; Variables (macros) that should be exported by loongarch.opt: +-; la_opt_switches, +-; la_opt_abi_base, la_opt_abi_ext, +-; la_opt_cpu_arch, la_opt_cpu_tune, +-; la_opt_fpu, +-; la_cmodel. +- + HeaderInclude + config/loongarch/loongarch-opts.h + + HeaderInclude + config/loongarch/loongarch-str.h + +-Variable +-HOST_WIDE_INT la_opt_switches = 0 +- + ; ISA related options + ;; Base ISA + Enum +@@ -42,14 +32,13 @@ Basic ISAs of LoongArch: + EnumValue + Enum(isa_base) String(@@STR_ISA_BASE_LA64V100@@) Value(ISA_BASE_LA64V100) + +- + ;; ISA extensions / adjustments + Enum + Name(isa_ext_fpu) Type(int) + FPU types of LoongArch: + + EnumValue +-Enum(isa_ext_fpu) String(@@STR_ISA_EXT_NOFPU@@) Value(ISA_EXT_NOFPU) ++Enum(isa_ext_fpu) String(@@STR_NONE@@) Value(ISA_EXT_NONE) + + EnumValue + Enum(isa_ext_fpu) String(@@STR_ISA_EXT_FPU32@@) Value(ISA_EXT_FPU32) +@@ -58,24 +47,48 @@ EnumValue + Enum(isa_ext_fpu) String(@@STR_ISA_EXT_FPU64@@) Value(ISA_EXT_FPU64) + + m@@OPTSTR_ISA_EXT_FPU@@= +-Target RejectNegative Joined ToLower Enum(isa_ext_fpu) Var(la_opt_fpu) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined ToLower Enum(isa_ext_fpu) Var(la_opt_fpu) Init(M_OPT_UNSET) + -m@@OPTSTR_ISA_EXT_FPU@@=FPU Generate code for the given FPU. + + m@@OPTSTR_ISA_EXT_FPU@@=@@STR_ISA_EXT_FPU0@@ +-Target RejectNegative Alias(m@@OPTSTR_ISA_EXT_FPU@@=,@@STR_ISA_EXT_NOFPU@@) ++Target RejectNegative Alias(m@@OPTSTR_ISA_EXT_FPU@@=,@@STR_NONE@@) + + m@@OPTSTR_SOFT_FLOAT@@ +-Target Driver RejectNegative Var(la_opt_switches) Mask(FORCE_SOFTF) Negative(m@@OPTSTR_SINGLE_FLOAT@@) ++Target Driver Defer Var(la_deferred_options) RejectNegative Negative(m@@OPTSTR_SINGLE_FLOAT@@) + Prevent the use of all hardware floating-point instructions. + + m@@OPTSTR_SINGLE_FLOAT@@ +-Target Driver RejectNegative Var(la_opt_switches) Mask(FORCE_F32) Negative(m@@OPTSTR_DOUBLE_FLOAT@@) ++Target Driver Defer Var(la_deferred_options) RejectNegative Negative(m@@OPTSTR_DOUBLE_FLOAT@@) + Restrict the use of hardware floating-point instructions to 32-bit operations. + + m@@OPTSTR_DOUBLE_FLOAT@@ +-Target Driver RejectNegative Var(la_opt_switches) Mask(FORCE_F64) Negative(m@@OPTSTR_SOFT_FLOAT@@) ++Target Driver Defer Var(la_deferred_options) RejectNegative Negative(m@@OPTSTR_SOFT_FLOAT@@) + Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations. + ++Enum ++Name(isa_ext_simd) Type(int) ++SIMD extension levels of LoongArch: ++ ++EnumValue ++Enum(isa_ext_simd) String(@@STR_NONE@@) Value(ISA_EXT_NONE) ++ ++EnumValue ++Enum(isa_ext_simd) String(@@STR_ISA_EXT_LSX@@) Value(ISA_EXT_SIMD_LSX) ++ ++EnumValue ++Enum(isa_ext_simd) String(@@STR_ISA_EXT_LASX@@) Value(ISA_EXT_SIMD_LASX) ++ ++m@@OPTSTR_ISA_EXT_SIMD@@= ++Target RejectNegative Joined ToLower Enum(isa_ext_simd) Var(la_opt_simd) Init(M_OPT_UNSET) ++-m@@OPTSTR_ISA_EXT_SIMD@@=SIMD Generate code for the given SIMD extension. ++ ++m@@STR_ISA_EXT_LSX@@ ++Target Driver Defer Var(la_deferred_options) ++Enable LoongArch SIMD Extension (LSX, 128-bit). ++ ++m@@STR_ISA_EXT_LASX@@ ++Target Driver Defer Var(la_deferred_options) ++Enable LoongArch Advanced SIMD Extension (LASX, 256-bit). + + ;; Base target models (implies ISA & tune parameters) + Enum +@@ -85,6 +98,9 @@ LoongArch CPU types: + EnumValue + Enum(cpu_type) String(@@STR_CPU_NATIVE@@) Value(CPU_NATIVE) + ++EnumValue ++Enum(cpu_type) String(@@STR_CPU_ABI_DEFAULT@@) Value(CPU_ABI_DEFAULT) ++ + EnumValue + Enum(cpu_type) String(@@STR_CPU_LOONGARCH64@@) Value(CPU_LOONGARCH64) + +@@ -92,11 +108,11 @@ EnumValue + Enum(cpu_type) String(@@STR_CPU_LA464@@) Value(CPU_LA464) + + m@@OPTSTR_ARCH@@= +-Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET) + -m@@OPTSTR_ARCH@@=PROCESSOR Generate code for the given PROCESSOR ISA. + + m@@OPTSTR_TUNE@@= +-Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_tune) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_tune) Init(M_OPT_UNSET) + -m@@OPTSTR_TUNE@@=PROCESSOR Generate optimized code for PROCESSOR. + + +@@ -118,13 +134,13 @@ EnumValue + Enum(abi_base) String(@@STR_ABI_BASE_LP64S@@) Value(ABI_BASE_LP64S) + + m@@OPTSTR_ABI_BASE@@= +-Target RejectNegative Joined ToLower Enum(abi_base) Var(la_opt_abi_base) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined ToLower Enum(abi_base) Var(la_opt_abi_base) Init(M_OPT_UNSET) + -m@@OPTSTR_ABI_BASE@@=BASEABI Generate code that conforms to the given BASEABI. + ++ + ;; ABI Extension + Variable +-int la_opt_abi_ext = M_OPTION_NOT_SEEN +- ++int la_opt_abi_ext = M_OPT_UNSET + + mbranch-cost= + Target RejectNegative Joined UInteger Var(loongarch_branch_cost) +@@ -182,7 +198,7 @@ EnumValue + Enum(cmodel) String(@@STR_CMODEL_EXTREME@@) Value(CMODEL_EXTREME) + + mcmodel= +-Target RejectNegative Joined Enum(cmodel) Var(la_opt_cmodel) Init(CMODEL_NORMAL) ++Target RejectNegative Joined Enum(cmodel) Var(la_opt_cmodel) Init(M_OPT_UNSET) + Specify the code model. + + mdirect-extern-access +diff --git a/gcc/config/loongarch/la464.md b/gcc/config/loongarch/la464.md +index 0ae177610..89d61bf58 100644 +--- a/gcc/config/loongarch/la464.md ++++ b/gcc/config/loongarch/la464.md +@@ -43,88 +43,88 @@ + ;; Describe instruction reservations. + + (define_insn_reservation "la464_arith" 1 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "arith,clz,const,logical, + move,nop,shift,signext,slt")) + "la464_alu1 | la464_alu2") + + (define_insn_reservation "la464_branch" 1 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "branch,jump,call,condmove,trap")) + "la464_alu1 | la464_alu2") + + (define_insn_reservation "la464_imul" 7 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "imul")) + "la464_alu1 | la464_alu2") + + (define_insn_reservation "la464_idiv_si" 12 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (and (eq_attr "type" "idiv") + (eq_attr "mode" "SI"))) + "la464_alu1 | la464_alu2") + + (define_insn_reservation "la464_idiv_di" 25 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (and (eq_attr "type" "idiv") + (eq_attr "mode" "DI"))) + "la464_alu1 | la464_alu2") + + (define_insn_reservation "la464_load" 4 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "load")) + "la464_mem1 | la464_mem2") + + (define_insn_reservation "la464_gpr_fp" 16 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "mftg,mgtf")) + "la464_mem1") + + (define_insn_reservation "la464_fpload" 4 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "fpload")) + "la464_mem1 | la464_mem2") + + (define_insn_reservation "la464_prefetch" 0 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "prefetch,prefetchx")) + "la464_mem1 | la464_mem2") + + (define_insn_reservation "la464_store" 0 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "store,fpstore,fpidxstore")) + "la464_mem1 | la464_mem2") + + (define_insn_reservation "la464_fadd" 4 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "fadd,fmul,fmadd")) + "la464_falu1 | la464_falu2") + + (define_insn_reservation "la464_fcmp" 2 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "fabs,fcmp,fmove,fneg")) + "la464_falu1 | la464_falu2") + + (define_insn_reservation "la464_fcvt" 4 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "fcvt")) + "la464_falu1 | la464_falu2") + + (define_insn_reservation "la464_fdiv_sf" 12 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (and (eq_attr "type" "fdiv,frdiv,fsqrt,frsqrt") + (eq_attr "mode" "SF"))) + "la464_falu1 | la464_falu2") + + (define_insn_reservation "la464_fdiv_df" 19 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (and (eq_attr "type" "fdiv,frdiv,fsqrt,frsqrt") + (eq_attr "mode" "DF"))) + "la464_falu1 | la464_falu2") + + ;; Force single-dispatch for unknown or multi. + (define_insn_reservation "la464_unknown" 1 +- (and (match_test "TARGET_TUNE_LA464") ++ (and (match_test "TARGET_uARCH_LA464") + (eq_attr "type" "unknown,multi,atomic,syncloop")) + "la464_alu1 + la464_alu2 + la464_falu1 + + la464_falu2 + la464_mem1 + la464_mem2") +diff --git a/gcc/config/loongarch/loongarch-c.cc b/gcc/config/loongarch/loongarch-c.cc +index f779a7355..2cf84eec7 100644 +--- a/gcc/config/loongarch/loongarch-c.cc ++++ b/gcc/config/loongarch/loongarch-c.cc +@@ -61,8 +61,8 @@ loongarch_cpu_cpp_builtins (cpp_reader *pfile) + builtin_assert ("cpu=loongarch"); + builtin_define ("__loongarch__"); + +- LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_ARCH", LARCH_ACTUAL_ARCH); +- LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_TUNE", LARCH_ACTUAL_TUNE); ++ LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_ARCH", la_target.cpu_arch); ++ LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_TUNE", la_target.cpu_tune); + + /* Base architecture / ABI. */ + if (TARGET_64BIT) +@@ -99,6 +99,21 @@ loongarch_cpu_cpp_builtins (cpp_reader *pfile) + else + builtin_define ("__loongarch_frlen=0"); + ++ if (ISA_HAS_LSX) ++ { ++ builtin_define ("__loongarch_simd"); ++ builtin_define ("__loongarch_sx"); ++ ++ if (!ISA_HAS_LASX) ++ builtin_define ("__loongarch_simd_width=128"); ++ } ++ ++ if (ISA_HAS_LASX) ++ { ++ builtin_define ("__loongarch_asx"); ++ builtin_define ("__loongarch_simd_width=256"); ++ } ++ + /* Add support for FLOAT128_TYPE on the LoongArch architecture. */ + builtin_define ("__FLOAT128_TYPE__"); + +diff --git a/gcc/config/loongarch/loongarch-cpu.cc b/gcc/config/loongarch/loongarch-cpu.cc +index a886dd932..ea05526d7 100644 +--- a/gcc/config/loongarch/loongarch-cpu.cc ++++ b/gcc/config/loongarch/loongarch-cpu.cc +@@ -26,6 +26,7 @@ along with GCC; see the file COPYING3. If not see + #include "tm.h" + #include "diagnostic-core.h" + ++#include "loongarch-def.h" + #include "loongarch-opts.h" + #include "loongarch-cpu.h" + #include "loongarch-str.h" +@@ -80,127 +81,191 @@ get_native_prid_str (void) + } + + /* Fill property tables for CPU_NATIVE. */ +-unsigned int +-fill_native_cpu_config (int p_arch_native, int p_tune_native) ++void ++fill_native_cpu_config (struct loongarch_target *tgt) + { +- int ret_cpu_type; ++ int arch_native_p = tgt->cpu_arch == CPU_NATIVE; ++ int tune_native_p = tgt->cpu_tune == CPU_NATIVE; ++ int native_cpu_type = CPU_NATIVE; + + /* Nothing needs to be done unless "-march/tune=native" + is given or implied. */ +- if (!(p_arch_native || p_tune_native)) +- return CPU_NATIVE; ++ if (!arch_native_p && !tune_native_p) ++ return; + + /* Fill cpucfg_cache with the "cpucfg" instruction. */ + cache_cpucfg (); + +- +- /* Fill: loongarch_cpu_default_isaCPU_NATIVE.base +- With: base architecture (ARCH) +- At: cpucfg_words11:0 */ +- +- #define NATIVE_BASE_ISA (loongarch_cpu_default_isaCPU_NATIVE.base) +- switch (cpucfg_cache1 & 0x3) +- { +- case 0x02: +- NATIVE_BASE_ISA = ISA_BASE_LA64V100; +- break; +- +- default: +- if (p_arch_native) +- fatal_error (UNKNOWN_LOCATION, +- "unknown base architecture %<0x%x%>, %qs failed", +- (unsigned int) (cpucfg_cache1 & 0x3), +- "-m" OPTSTR_ARCH "=" STR_CPU_NATIVE); +- } +- +- /* Fill: loongarch_cpu_default_isaCPU_NATIVE.fpu +- With: FPU type (FP, FP_SP, FP_DP) +- At: cpucfg_words22:0 */ +- +- #define NATIVE_FPU (loongarch_cpu_default_isaCPU_NATIVE.fpu) +- switch (cpucfg_cache2 & 0x7) +- { +- case 0x07: +- NATIVE_FPU = ISA_EXT_FPU64; +- break; +- +- case 0x03: +- NATIVE_FPU = ISA_EXT_FPU32; +- break; +- +- case 0x00: +- NATIVE_FPU = ISA_EXT_NOFPU; +- break; +- +- default: +- if (p_arch_native) +- fatal_error (UNKNOWN_LOCATION, +- "unknown FPU type %<0x%x%>, %qs failed", +- (unsigned int) (cpucfg_cache2 & 0x7), +- "-m" OPTSTR_ARCH "=" STR_CPU_NATIVE); +- } +- +- /* Fill: loongarch_cpu_cacheCPU_NATIVE +- With: cache size info +- At: cpucfg_words16:2031:0 */ +- +- int l1d_present = 0, l1u_present = 0; +- int l2d_present = 0; +- uint32_t l1_szword, l2_szword; +- +- l1u_present |= cpucfg_cache16 & 3; /* bit1:0: unified l1 cache */ +- l1d_present |= cpucfg_cache16 & 4; /* bit2:2: l1 dcache */ +- l1_szword = l1d_present ? 18 : (l1u_present ? 17 : 0); +- l1_szword = l1_szword ? cpucfg_cachel1_szword: 0; +- +- l2d_present |= cpucfg_cache16 & 24; /* bit4:3: unified l2 cache */ +- l2d_present |= cpucfg_cache16 & 128; /* bit7:7: l2 dcache */ +- l2_szword = l2d_present ? cpucfg_cache19: 0; +- +- loongarch_cpu_cacheCPU_NATIVE.l1d_line_size +- = 1 << ((l1_szword & 0x7f000000) >> 24); /* bit30:24: log2(linesize) */ +- +- loongarch_cpu_cacheCPU_NATIVE.l1d_size +- = (1 << ((l1_szword & 0x00ff0000) >> 16)) /* bit23:16: log2(idx) */ +- * ((l1_szword & 0x0000ffff) + 1) /* bit15:0: sets - 1 */ +- * (1 << ((l1_szword & 0x7f000000) >> 24)) /* bit30:24: log2(linesize) */ +- >> 10; /* in kilobytes */ +- +- loongarch_cpu_cacheCPU_NATIVE.l2d_size +- = (1 << ((l2_szword & 0x00ff0000) >> 16)) /* bit23:16: log2(idx) */ +- * ((l2_szword & 0x0000ffff) + 1) /* bit15:0: sets - 1 */ +- * (1 << ((l2_szword & 0x7f000000) >> 24)) /* bit30:24: log2(linesize) */ +- >> 10; /* in kilobytes */ +- +- /* Fill: ret_cpu_type ++ /* Fill: tgt->cpu_arch | tgt->cpu_tune + With: processor ID (PRID) + At: cpucfg_words031:0 */ + + switch (cpucfg_cache0 & 0x00ffff00) + { + case 0x0014c000: /* LA464 */ +- ret_cpu_type = CPU_LA464; ++ native_cpu_type = CPU_LA464; + break; + + default: +- /* Unknown PRID. This is generally harmless as long as +- the properties above can be obtained via "cpucfg". */ +- if (p_tune_native) ++ /* Unknown PRID. */ ++ if (tune_native_p) + inform (UNKNOWN_LOCATION, "unknown processor ID %<0x%x%>, " + "some tuning parameters will fall back to default", + cpucfg_cache0); + break; + } + +- /* Properties that cannot be looked up directly using cpucfg. */ +- loongarch_cpu_issue_rateCPU_NATIVE +- = loongarch_cpu_issue_rateret_cpu_type; +- +- loongarch_cpu_multipass_dfa_lookaheadCPU_NATIVE +- = loongarch_cpu_multipass_dfa_lookaheadret_cpu_type; +- +- loongarch_cpu_rtx_cost_dataCPU_NATIVE +- = loongarch_cpu_rtx_cost_dataret_cpu_type; ++ /* if -march=native */ ++ if (arch_native_p) ++ { ++ int tmp; ++ tgt->cpu_arch = native_cpu_type; ++ ++ /* Fill: loongarch_cpu_default_isatgt->cpu_arch.base ++ With: base architecture (ARCH) ++ At: cpucfg_words11:0 */ ++ ++ #define PRESET_ARCH (loongarch_cpu_default_isatgt->cpu_arch.base) ++ switch (cpucfg_cache1 & 0x3) ++ { ++ case 0x02: ++ tmp = ISA_BASE_LA64V100; ++ break; ++ ++ default: ++ fatal_error (UNKNOWN_LOCATION, ++ "unknown native base architecture %<0x%x%>, " ++ "%qs failed", (unsigned int) (cpucfg_cache1 & 0x3), ++ "-m" OPTSTR_ARCH "=" STR_CPU_NATIVE); ++ } ++ ++ /* Check consistency with PRID presets. */ ++ if (native_cpu_type != CPU_NATIVE && tmp != PRESET_ARCH) ++ warning (0, "base architecture %qs differs from PRID preset %qs", ++ loongarch_isa_base_stringstmp, ++ loongarch_isa_base_stringsPRESET_ARCH); ++ ++ /* Use the native value anyways. */ ++ PRESET_ARCH = tmp; ++ ++ /* Fill: loongarch_cpu_default_isatgt->cpu_arch.fpu ++ With: FPU type (FP, FP_SP, FP_DP) ++ At: cpucfg_words22:0 */ ++ ++ #define PRESET_FPU (loongarch_cpu_default_isatgt->cpu_arch.fpu) ++ switch (cpucfg_cache2 & 0x7) ++ { ++ case 0x07: ++ tmp = ISA_EXT_FPU64; ++ break; ++ ++ case 0x03: ++ tmp = ISA_EXT_FPU32; ++ break; ++ ++ case 0x00: ++ tmp = ISA_EXT_NONE; ++ break; ++ ++ default: ++ fatal_error (UNKNOWN_LOCATION, ++ "unknown native FPU type %<0x%x%>, %qs failed", ++ (unsigned int) (cpucfg_cache2 & 0x7), ++ "-m" OPTSTR_ARCH "=" STR_CPU_NATIVE); ++ } ++ ++ /* Check consistency with PRID presets. */ ++ if (native_cpu_type != CPU_NATIVE && tmp != PRESET_FPU) ++ warning (0, "floating-point unit %qs differs from PRID preset %qs", ++ loongarch_isa_ext_stringstmp, ++ loongarch_isa_ext_stringsPRESET_FPU); ++ ++ /* Use the native value anyways. */ ++ PRESET_FPU = tmp; ++ ++ ++ /* Fill: loongarch_cpu_default_isaCPU_NATIVE.simd ++ With: SIMD extension type (LSX, LASX) ++ At: cpucfg_words27:6 */ ++ ++ #define PRESET_SIMD (loongarch_cpu_default_isatgt->cpu_arch.simd) ++ switch (cpucfg_cache2 & 0xc0) ++ { ++ case 0xc0: ++ tmp = ISA_EXT_SIMD_LASX; ++ break; ++ ++ case 0x40: ++ tmp = ISA_EXT_SIMD_LSX; ++ break; ++ ++ case 0x80: ++ tmp = 0; ++ warning (0, "unknown SIMD extension " ++ "(%qs disabled while %qs is enabled), disabling SIMD", ++ loongarch_isa_ext_stringsISA_EXT_SIMD_LSX, ++ loongarch_isa_ext_stringsISA_EXT_SIMD_LASX); ++ break; ++ ++ case 0x00: ++ tmp = 0; ++ break; ++ } ++ ++ /* Check consistency with PRID presets. */ ++ ++ /* ++ if (native_cpu_type != CPU_NATIVE && tmp != PRESET_SIMD) ++ warning (0, "SIMD extension %qs differs from PRID preset %qs", ++ loongarch_isa_ext_stringstmp, ++ loongarch_isa_ext_stringsPRESET_SIMD); ++ */ ++ ++ /* Use the native value anyways. */ ++ PRESET_SIMD = tmp; ++ } + +- return ret_cpu_type; ++ if (tune_native_p) ++ { ++ tgt->cpu_tune = native_cpu_type; ++ ++ /* Fill: loongarch_cpu_cachetgt->cpu_tune ++ With: cache size info ++ At: cpucfg_words16:2031:0 */ ++ ++ #define PRESET_CACHE (loongarch_cpu_cachetgt->cpu_tune) ++ struct loongarch_cache native_cache; ++ int l1d_present = 0, l1u_present = 0; ++ int l2d_present = 0; ++ uint32_t l1_szword, l2_szword; ++ ++ l1u_present |= cpucfg_cache16 & 3; /* bit1:0: unified l1 */ ++ l1d_present |= cpucfg_cache16 & 4; /* bit2:2: l1d */ ++ l1_szword = l1d_present ? 18 : (l1u_present ? 17 : 0); ++ l1_szword = l1_szword ? cpucfg_cachel1_szword: 0; ++ ++ l2d_present |= cpucfg_cache16 & 24; /* bit4:3: unified l2 */ ++ l2d_present |= cpucfg_cache16 & 128; /* bit7:7: l2d */ ++ l2_szword = l2d_present ? cpucfg_cache19: 0; ++ ++ native_cache.l1d_line_size ++ = 1 << ((l1_szword & 0x7f000000) >> 24); /* bit30:24: log2(line) */ ++ ++ native_cache.l1d_size ++ = (1 << ((l1_szword & 0x00ff0000) >> 16)) /* bit23:16: log2(idx) */ ++ * ((l1_szword & 0x0000ffff) + 1) /* bit15:0: sets - 1 */ ++ * (1 << ((l1_szword & 0x7f000000) >> 24)) /* bit30:24: log2(line) */ ++ >> 10; /* in kibibytes */ ++ ++ native_cache.l2d_size ++ = (1 << ((l2_szword & 0x00ff0000) >> 16)) /* bit23:16: log2(idx) */ ++ * ((l2_szword & 0x0000ffff) + 1) /* bit15:0: sets - 1 */ ++ * (1 << ((l2_szword & 0x7f000000) >> 24)) /* bit30:24: log2(linesz) */ ++ >> 10; /* in kibibytes */ ++ ++ /* Use the native value anyways. */ ++ PRESET_CACHE.l1d_line_size = native_cache.l1d_line_size; ++ PRESET_CACHE.l1d_size = native_cache.l1d_size; ++ PRESET_CACHE.l2d_size = native_cache.l2d_size; ++ } + } +diff --git a/gcc/config/loongarch/loongarch-cpu.h b/gcc/config/loongarch/loongarch-cpu.h +index 93d656f70..eacb38774 100644 +--- a/gcc/config/loongarch/loongarch-cpu.h ++++ b/gcc/config/loongarch/loongarch-cpu.h +@@ -21,9 +21,10 @@ along with GCC; see the file COPYING3. If not see + #define LOONGARCH_CPU_H + + #include "system.h" ++#include "loongarch-def.h" + + void cache_cpucfg (void); +-unsigned int fill_native_cpu_config (int p_arch_native, int p_tune_native); ++void fill_native_cpu_config (struct loongarch_target *tgt); + uint32_t get_native_prid (void); + const char* get_native_prid_str (void); + +diff --git a/gcc/config/loongarch/loongarch-def.c b/gcc/config/loongarch/loongarch-def.c +index 74d422ce0..d29d5f001 100644 +--- a/gcc/config/loongarch/loongarch-def.c ++++ b/gcc/config/loongarch/loongarch-def.c +@@ -21,25 +21,11 @@ along with GCC; see the file COPYING3. If not see + #include "loongarch-def.h" + #include "loongarch-str.h" + +-/* Default RTX cost initializer. */ +-#define COSTS_N_INSNS(N) ((N) * 4) +-#define DEFAULT_COSTS \ +- .fp_add = COSTS_N_INSNS (1), \ +- .fp_mult_sf = COSTS_N_INSNS (2), \ +- .fp_mult_df = COSTS_N_INSNS (4), \ +- .fp_div_sf = COSTS_N_INSNS (6), \ +- .fp_div_df = COSTS_N_INSNS (8), \ +- .int_mult_si = COSTS_N_INSNS (1), \ +- .int_mult_di = COSTS_N_INSNS (1), \ +- .int_div_si = COSTS_N_INSNS (4), \ +- .int_div_di = COSTS_N_INSNS (6), \ +- .branch_cost = 2, \ +- .memory_latency = 4 +- + /* CPU property tables. */ + const char* + loongarch_cpu_stringsN_TUNE_TYPES = { + CPU_NATIVE = STR_CPU_NATIVE, ++ CPU_ABI_DEFAULT = STR_CPU_ABI_DEFAULT, + CPU_LOONGARCH64 = STR_CPU_LOONGARCH64, + CPU_LA464 = STR_CPU_LA464, + }; +@@ -49,10 +35,12 @@ loongarch_cpu_default_isaN_ARCH_TYPES = { + CPU_LOONGARCH64 = { + .base = ISA_BASE_LA64V100, + .fpu = ISA_EXT_FPU64, ++ .simd = 0, + }, + CPU_LA464 = { + .base = ISA_BASE_LA64V100, + .fpu = ISA_EXT_FPU64, ++ .simd = ISA_EXT_SIMD_LASX, + }, + }; + +@@ -84,6 +72,22 @@ loongarch_cpu_alignN_TUNE_TYPES = { + }, + }; + ++ ++/* Default RTX cost initializer. */ ++#define COSTS_N_INSNS(N) ((N) * 4) ++#define DEFAULT_COSTS \ ++ .fp_add = COSTS_N_INSNS (1), \ ++ .fp_mult_sf = COSTS_N_INSNS (2), \ ++ .fp_mult_df = COSTS_N_INSNS (4), \ ++ .fp_div_sf = COSTS_N_INSNS (6), \ ++ .fp_div_df = COSTS_N_INSNS (8), \ ++ .int_mult_si = COSTS_N_INSNS (1), \ ++ .int_mult_di = COSTS_N_INSNS (1), \ ++ .int_div_si = COSTS_N_INSNS (4), \ ++ .int_div_di = COSTS_N_INSNS (6), \ ++ .branch_cost = 2, \ ++ .memory_latency = 4 ++ + /* The following properties cannot be looked up directly using "cpucfg". + So it is necessary to provide a default value for "unknown native" + tune targets (i.e. -mtune=native while PRID does not correspond to +@@ -103,7 +107,7 @@ loongarch_cpu_rtx_cost_dataN_TUNE_TYPES = { + }; + + /* RTX costs to use when optimizing for size. */ +-extern const struct loongarch_rtx_cost_data ++const struct loongarch_rtx_cost_data + loongarch_rtx_cost_optimize_size = { + .fp_add = 4, + .fp_mult_sf = 4, +@@ -144,9 +148,11 @@ loongarch_isa_base_stringsN_ISA_BASE_TYPES = { + + const char* + loongarch_isa_ext_stringsN_ISA_EXT_TYPES = { +- ISA_EXT_FPU64 = STR_ISA_EXT_FPU64, ++ ISA_EXT_NONE = STR_NONE, + ISA_EXT_FPU32 = STR_ISA_EXT_FPU32, +- ISA_EXT_NOFPU = STR_ISA_EXT_NOFPU, ++ ISA_EXT_FPU64 = STR_ISA_EXT_FPU64, ++ ISA_EXT_SIMD_LSX = STR_ISA_EXT_LSX, ++ ISA_EXT_SIMD_LASX = STR_ISA_EXT_LASX, + }; + + const char* +@@ -171,24 +177,29 @@ loongarch_cmodel_strings = { + CMODEL_EXTREME = STR_CMODEL_EXTREME, + }; + +-const char* +-loongarch_switch_strings = { +- SW_SOFT_FLOAT = OPTSTR_SOFT_FLOAT, +- SW_SINGLE_FLOAT = OPTSTR_SINGLE_FLOAT, +- SW_DOUBLE_FLOAT = OPTSTR_DOUBLE_FLOAT, +-}; +- + + /* ABI-related definitions. */ + const struct loongarch_isa + abi_minimal_isaN_ABI_BASE_TYPESN_ABI_EXT_TYPES = { + ABI_BASE_LP64D = { +- ABI_EXT_BASE = {.base = ISA_BASE_LA64V100, .fpu = ISA_EXT_FPU64}, ++ ABI_EXT_BASE = { ++ .base = ISA_BASE_LA64V100, ++ .fpu = ISA_EXT_FPU64, ++ .simd = 0 ++ }, + }, + ABI_BASE_LP64F = { +- ABI_EXT_BASE = {.base = ISA_BASE_LA64V100, .fpu = ISA_EXT_FPU32}, ++ ABI_EXT_BASE = { ++ .base = ISA_BASE_LA64V100, ++ .fpu = ISA_EXT_FPU32, ++ .simd = 0 ++ }, + }, + ABI_BASE_LP64S = { +- ABI_EXT_BASE = {.base = ISA_BASE_LA64V100, .fpu = ISA_EXT_NOFPU}, ++ ABI_EXT_BASE = { ++ .base = ISA_BASE_LA64V100, ++ .fpu = ISA_EXT_NONE, ++ .simd = 0 ++ }, + }, + }; +diff --git a/gcc/config/loongarch/loongarch-def.h b/gcc/config/loongarch/loongarch-def.h +index eb87a79a5..0aee7dc19 100644 +--- a/gcc/config/loongarch/loongarch-def.h ++++ b/gcc/config/loongarch/loongarch-def.h +@@ -59,11 +59,13 @@ extern const char* loongarch_isa_base_strings; + + /* enum isa_ext_* */ + extern const char* loongarch_isa_ext_strings; +-#define ISA_EXT_NOFPU 0 ++#define ISA_EXT_NONE 0 + #define ISA_EXT_FPU32 1 + #define ISA_EXT_FPU64 2 + #define N_ISA_EXT_FPU_TYPES 3 +-#define N_ISA_EXT_TYPES 3 ++#define ISA_EXT_SIMD_LSX 3 ++#define ISA_EXT_SIMD_LASX 4 ++#define N_ISA_EXT_TYPES 5 + + /* enum abi_base */ + extern const char* loongarch_abi_base_strings; +@@ -72,6 +74,16 @@ extern const char* loongarch_abi_base_strings; + #define ABI_BASE_LP64S 2 + #define N_ABI_BASE_TYPES 3 + ++#define TO_LP64_ABI_BASE(C) (C) ++ ++#define ABI_FPU_64(abi_base) \ ++ (abi_base == ABI_BASE_LP64D) ++#define ABI_FPU_32(abi_base) \ ++ (abi_base == ABI_BASE_LP64F) ++#define ABI_FPU_NONE(abi_base) \ ++ (abi_base == ABI_BASE_LP64S) ++ ++ + /* enum abi_ext */ + extern const char* loongarch_abi_ext_strings; + #define ABI_EXT_BASE 0 +@@ -87,55 +99,44 @@ extern const char* loongarch_cmodel_strings; + #define CMODEL_EXTREME 5 + #define N_CMODEL_TYPES 6 + +-/* enum switches */ +-/* The "SW_" codes represent command-line switches (options that +- accept no parameters). Definition for other switches that affects +- the target ISA / ABI configuration will also be appended here +- in the future. */ +- +-extern const char* loongarch_switch_strings; +-#define SW_SOFT_FLOAT 0 +-#define SW_SINGLE_FLOAT 1 +-#define SW_DOUBLE_FLOAT 2 +-#define N_SWITCH_TYPES 3 +- + /* The common default value for variables whose assignments + are triggered by command-line options. */ + +-#define M_OPTION_NOT_SEEN -1 +-#define M_OPT_ABSENT(opt_enum) ((opt_enum) == M_OPTION_NOT_SEEN) ++#define M_OPT_UNSET -1 ++#define M_OPT_ABSENT(opt_enum) ((opt_enum) == M_OPT_UNSET) + + + /* Internal representation of the target. */ + struct loongarch_isa + { +- unsigned char base; /* ISA_BASE_ */ +- unsigned char fpu; /* ISA_EXT_FPU_ */ ++ int base; /* ISA_BASE_ */ ++ int fpu; /* ISA_EXT_FPU_ */ ++ int simd; /* ISA_EXT_SIMD_ */ + }; + + struct loongarch_abi + { +- unsigned char base; /* ABI_BASE_ */ +- unsigned char ext; /* ABI_EXT_ */ ++ int base; /* ABI_BASE_ */ ++ int ext; /* ABI_EXT_ */ + }; + + struct loongarch_target + { + struct loongarch_isa isa; + struct loongarch_abi abi; +- unsigned char cpu_arch; /* CPU_ */ +- unsigned char cpu_tune; /* same */ +- unsigned char cpu_native; /* same */ +- unsigned char cmodel; /* CMODEL_ */ ++ int cpu_arch; /* CPU_ */ ++ int cpu_tune; /* same */ ++ int cmodel; /* CMODEL_ */ + }; + + /* CPU properties. */ + /* index */ + #define CPU_NATIVE 0 +-#define CPU_LOONGARCH64 1 +-#define CPU_LA464 2 +-#define N_ARCH_TYPES 3 +-#define N_TUNE_TYPES 3 ++#define CPU_ABI_DEFAULT 1 ++#define CPU_LOONGARCH64 2 ++#define CPU_LA464 3 ++#define N_ARCH_TYPES 4 ++#define N_TUNE_TYPES 4 + + /* parallel tables. */ + extern const char* loongarch_cpu_strings; +diff --git a/gcc/config/loongarch/loongarch-driver.cc b/gcc/config/loongarch/loongarch-driver.cc +index 0adcc923b..b3626984d 100644 +--- a/gcc/config/loongarch/loongarch-driver.cc ++++ b/gcc/config/loongarch/loongarch-driver.cc +@@ -26,122 +26,137 @@ along with GCC; see the file COPYING3. If not see + #include "tm.h" + #include "obstack.h" + #include "diagnostic-core.h" ++#include "opts.h" + + #include "loongarch-opts.h" + #include "loongarch-driver.h" + +-static int +- opt_arch_driver = M_OPTION_NOT_SEEN, +- opt_tune_driver = M_OPTION_NOT_SEEN, +- opt_fpu_driver = M_OPTION_NOT_SEEN, +- opt_abi_base_driver = M_OPTION_NOT_SEEN, +- opt_abi_ext_driver = M_OPTION_NOT_SEEN, +- opt_cmodel_driver = M_OPTION_NOT_SEEN; +- +-int opt_switches = 0; +- + /* This flag is set to 1 if we believe that the user might be avoiding + linking (implicitly) against something from the startfile search paths. */ + static int no_link = 0; + +-#define LARCH_DRIVER_SET_M_FLAG(OPTS_ARRAY, N_OPTS, FLAG, STR) \ +- for (int i = 0; i < (N_OPTS); i++) \ +- { \ +- if ((OPTS_ARRAY)i != 0) \ +- if (strcmp ((STR), (OPTS_ARRAY)i) == 0) \ +- (FLAG) = i; \ +- } +- + /* Use the public obstack from the gcc driver (defined in gcc.c). + This is for allocating space for the returned string. */ + extern struct obstack opts_obstack; + +-#define APPEND_LTR(S) \ +- obstack_grow (&opts_obstack, (const void*) (S), \ +- sizeof ((S)) / sizeof (char) -1) +- +-#define APPEND_VAL(S) \ +- obstack_grow (&opts_obstack, (const void*) (S), strlen ((S))) ++const char* ++la_driver_init (int argc ATTRIBUTE_UNUSED, const char **argv ATTRIBUTE_UNUSED) ++{ ++ /* Initialize all fields of la_target to -1 */ ++ loongarch_init_target (&la_target, M_OPT_UNSET, M_OPT_UNSET, M_OPT_UNSET, ++ M_OPT_UNSET, M_OPT_UNSET, M_OPT_UNSET, M_OPT_UNSET); ++ return ""; ++} + ++const char* ++driver_set_no_link (int argc ATTRIBUTE_UNUSED, ++ const char **argv ATTRIBUTE_UNUSED) ++{ ++ no_link = 1; ++ return ""; ++} + + const char* +-driver_set_m_flag (int argc, const char **argv) ++driver_set_m_parm (int argc, const char **argv) + { +- int parm_off = 0; ++ gcc_assert (argc == 2); ++ ++#define LARCH_DRIVER_PARSE_PARM(OPT_IDX, NAME, OPTSTR_LIST, \ ++ OPT_IDX_LO, OPT_IDX_HI) \ ++ if (strcmp (argv0, OPTSTR_##NAME) == 0) \ ++ for (int i = (OPT_IDX_LO); i < (OPT_IDX_HI); i++) \ ++ { \ ++ if ((OPTSTR_LIST)i != 0) \ ++ if (strcmp (argv1, (OPTSTR_LIST)i) == 0) \ ++ { \ ++ (OPT_IDX) = i; \ ++ return 0; \ ++ } \ ++ } + +- if (argc != 1) +- return "%eset_m_flag requires exactly 1 argument."; ++ LARCH_DRIVER_PARSE_PARM (la_target.abi.base, ABI_BASE, \ ++ loongarch_abi_base_strings, 0, N_ABI_BASE_TYPES) + +-#undef PARM +-#define PARM (argv0 + parm_off) ++ LARCH_DRIVER_PARSE_PARM (la_target.isa.fpu, ISA_EXT_FPU, \ ++ loongarch_isa_ext_strings, 0, N_ISA_EXT_FPU_TYPES) + +-/* Note: sizeof (OPTSTR_##NAME) equals the length of "<option>=". */ +-#undef MATCH_OPT +-#define MATCH_OPT(NAME) \ +- (strncmp (argv0, OPTSTR_##NAME "=", \ +- (parm_off = sizeof (OPTSTR_##NAME))) == 0) ++ LARCH_DRIVER_PARSE_PARM (la_target.isa.simd, ISA_EXT_SIMD, \ ++ loongarch_isa_ext_strings, 0, N_ISA_EXT_TYPES) + +- if (strcmp (argv0, "no_link") == 0) +- { +- no_link = 1; +- } +- else if (MATCH_OPT (ABI_BASE)) +- { +- LARCH_DRIVER_SET_M_FLAG ( +- loongarch_abi_base_strings, N_ABI_BASE_TYPES, +- opt_abi_base_driver, PARM) +- } +- else if (MATCH_OPT (ISA_EXT_FPU)) +- { +- LARCH_DRIVER_SET_M_FLAG (loongarch_isa_ext_strings, N_ISA_EXT_FPU_TYPES, +- opt_fpu_driver, PARM) +- } +- else if (MATCH_OPT (ARCH)) +- { +- LARCH_DRIVER_SET_M_FLAG (loongarch_cpu_strings, N_ARCH_TYPES, +- opt_arch_driver, PARM) +- } +- else if (MATCH_OPT (TUNE)) +- { +- LARCH_DRIVER_SET_M_FLAG (loongarch_cpu_strings, N_TUNE_TYPES, +- opt_tune_driver, PARM) +- } +- else if (MATCH_OPT (CMODEL)) +- { +- LARCH_DRIVER_SET_M_FLAG (loongarch_cmodel_strings, N_CMODEL_TYPES, +- opt_cmodel_driver, PARM) +- } +- else /* switches */ +- { +- int switch_idx = M_OPTION_NOT_SEEN; ++ LARCH_DRIVER_PARSE_PARM (la_target.cpu_arch, ARCH, \ ++ loongarch_cpu_strings, 0, N_ARCH_TYPES) + +- LARCH_DRIVER_SET_M_FLAG (loongarch_switch_strings, N_SWITCH_TYPES, +- switch_idx, argv0) ++ LARCH_DRIVER_PARSE_PARM (la_target.cpu_tune, TUNE, \ ++ loongarch_cpu_strings, 0, N_TUNE_TYPES) + +- if (switch_idx != M_OPTION_NOT_SEEN) +- opt_switches |= loongarch_switch_maskswitch_idx; +- } +- return ""; ++ LARCH_DRIVER_PARSE_PARM (la_target.cmodel, CMODEL, \ ++ loongarch_cmodel_strings, 0, N_CMODEL_TYPES) ++ ++ gcc_unreachable (); ++} ++ ++static void ++driver_record_deferred_opts (struct loongarch_flags *flags) ++{ ++ unsigned int i; ++ cl_deferred_option *opt; ++ vec<cl_deferred_option> *v = (vec<cl_deferred_option> *) la_deferred_options; ++ ++ gcc_assert (flags); ++ ++ /* Initialize flags */ ++ flags->flt = M_OPT_UNSET; ++ flags->flt_str = NULL; ++ flags->sx0 = flags->sx1 = 0; ++ ++ int sx_flag_idx = 0; ++ ++ if (v) ++ FOR_EACH_VEC_ELT (*v, i, opt) ++ { ++ switch (opt->opt_index) ++ { ++ case OPT_mlsx: ++ flags->sxsx_flag_idx++ = ISA_EXT_SIMD_LSX ++ * (opt->value ? 1 : -1); ++ break; ++ ++ case OPT_mlasx: ++ flags->sxsx_flag_idx++ = ISA_EXT_SIMD_LASX ++ * (opt->value ? 1 : -1); ++ break; ++ ++ case OPT_msoft_float: ++ flags->flt = ISA_EXT_NONE; ++ flags->flt_str = OPTSTR_SOFT_FLOAT; ++ break; ++ ++ case OPT_msingle_float: ++ flags->flt = ISA_EXT_FPU32; ++ flags->flt_str = OPTSTR_SINGLE_FLOAT; ++ break; ++ ++ case OPT_mdouble_float: ++ flags->flt = ISA_EXT_FPU64; ++ flags->flt_str = OPTSTR_DOUBLE_FLOAT; ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ gcc_assert (sx_flag_idx <= 2); ++ } + } + + const char* +-driver_get_normalized_m_opts (int argc, const char **argv) ++driver_get_normalized_m_opts (int argc, const char **argv ATTRIBUTE_UNUSED) + { + if (argc != 0) +- { +- (void) argv; /* To make compiler shut up about unused argument. */ +- return " %eget_normalized_m_opts requires no argument.\n"; +- } ++ return " %eget_normalized_m_opts requires no argument.\n"; + +- loongarch_config_target (& la_target, +- opt_switches, +- opt_arch_driver, +- opt_tune_driver, +- opt_fpu_driver, +- opt_abi_base_driver, +- opt_abi_ext_driver, +- opt_cmodel_driver, +- !no_link /* follow_multilib_list */); ++ struct loongarch_flags flags; ++ driver_record_deferred_opts (&flags); ++ loongarch_config_target (&la_target, &flags, !no_link); + + /* Output normalized option strings. */ + obstack_blank (&opts_obstack, 0); +@@ -160,11 +175,15 @@ driver_get_normalized_m_opts (int argc, const char **argv) + APPEND_LTR (" %<m" OPTSTR_##NAME "=* " \ + " -m" OPTSTR_##NAME "=") + +- for (int i = 0; i < N_SWITCH_TYPES; i++) +- { +- APPEND_LTR (" %<m"); +- APPEND_VAL (loongarch_switch_stringsi); +- } ++#undef CLEAR_FLAG ++#define CLEAR_FLAG(NAME) \ ++ APPEND_LTR (" %<m" NAME " %<mno-" NAME) ++ ++ CLEAR_FLAG (STR_ISA_EXT_LSX); ++ CLEAR_FLAG (STR_ISA_EXT_LASX); ++ CLEAR_FLAG (OPTSTR_SOFT_FLOAT); ++ CLEAR_FLAG (OPTSTR_SINGLE_FLOAT); ++ CLEAR_FLAG (OPTSTR_DOUBLE_FLOAT); + + APPEND_OPT (ABI_BASE); + APPEND_VAL (loongarch_abi_base_stringsla_target.abi.base); +@@ -175,6 +194,9 @@ driver_get_normalized_m_opts (int argc, const char **argv) + APPEND_OPT (ISA_EXT_FPU); + APPEND_VAL (loongarch_isa_ext_stringsla_target.isa.fpu); + ++ APPEND_OPT (ISA_EXT_SIMD); ++ APPEND_VAL (loongarch_isa_ext_stringsla_target.isa.simd); ++ + APPEND_OPT (CMODEL); + APPEND_VAL (loongarch_cmodel_stringsla_target.cmodel); + +diff --git a/gcc/config/loongarch/loongarch-driver.h b/gcc/config/loongarch/loongarch-driver.h +index 2e4a7a9c8..6cfe0efb5 100644 +--- a/gcc/config/loongarch/loongarch-driver.h ++++ b/gcc/config/loongarch/loongarch-driver.h +@@ -24,33 +24,37 @@ along with GCC; see the file COPYING3. If not see + #include "loongarch-str.h" + + extern const char* +-driver_set_m_flag (int argc, const char **argv); ++la_driver_init (int argc, const char **argv); ++ ++extern const char* ++driver_set_m_parm (int argc, const char **argv); ++ ++extern const char* ++driver_set_no_link (int argc, const char **argv); + + extern const char* + driver_get_normalized_m_opts (int argc, const char **argv); + + #define EXTRA_SPEC_FUNCTIONS \ +- { "set_m_flag", driver_set_m_flag }, \ ++ { "driver_init", la_driver_init }, \ ++ { "set_m_parm", driver_set_m_parm }, \ ++ { "set_no_link", driver_set_no_link }, \ + { "get_normalized_m_opts", driver_get_normalized_m_opts }, + + /* Pre-process ABI-related options. */ + #define LA_SET_PARM_SPEC(NAME) \ +- " %{m" OPTSTR_##NAME "=*: %:set_m_flag(" OPTSTR_##NAME "=%*)}" \ +- +-#define LA_SET_FLAG_SPEC(NAME) \ +- " %{m" OPTSTR_##NAME ": %:set_m_flag(" OPTSTR_##NAME ")}" \ +- +-#define DRIVER_HANDLE_MACHINE_OPTIONS \ +- " %{c|S|E|nostdlib: %:set_m_flag(no_link)}" \ +- " %{nostartfiles: %{nodefaultlibs: %:set_m_flag(no_link)}}" \ +- LA_SET_PARM_SPEC (ABI_BASE) \ +- LA_SET_PARM_SPEC (ARCH) \ +- LA_SET_PARM_SPEC (TUNE) \ +- LA_SET_PARM_SPEC (ISA_EXT_FPU) \ +- LA_SET_PARM_SPEC (CMODEL) \ +- LA_SET_FLAG_SPEC (SOFT_FLOAT) \ +- LA_SET_FLAG_SPEC (SINGLE_FLOAT) \ +- LA_SET_FLAG_SPEC (DOUBLE_FLOAT) \ ++ " %{m" OPTSTR_##NAME "=*: %:set_m_parm(" OPTSTR_##NAME " %*)}" \ ++ ++#define DRIVER_HANDLE_MACHINE_OPTIONS \ ++ " %:driver_init()" \ ++ " %{c|S|E|nostdlib: %:set_no_link()}" \ ++ " %{nostartfiles: %{nodefaultlibs: %:set_no_link()}}" \ ++ LA_SET_PARM_SPEC (ABI_BASE) \ ++ LA_SET_PARM_SPEC (ARCH) \ ++ LA_SET_PARM_SPEC (TUNE) \ ++ LA_SET_PARM_SPEC (ISA_EXT_FPU) \ ++ LA_SET_PARM_SPEC (ISA_EXT_SIMD) \ ++ LA_SET_PARM_SPEC (CMODEL) \ + " %:get_normalized_m_opts()" + + #define DRIVER_SELF_SPECS \ +diff --git a/gcc/config/loongarch/loongarch-opts.cc b/gcc/config/loongarch/loongarch-opts.cc +index e13eafb58..200702b0e 100644 +--- a/gcc/config/loongarch/loongarch-opts.cc ++++ b/gcc/config/loongarch/loongarch-opts.cc +@@ -26,9 +26,11 @@ along with GCC; see the file COPYING3. If not see + #include "tm.h" + #include "obstack.h" + #include "diagnostic-core.h" ++ + #include "loongarch-cpu.h" + #include "loongarch-opts.h" + #include "loongarch-str.h" ++#include "loongarch-def.h" + + struct loongarch_target la_target; + +@@ -76,16 +78,6 @@ init_enabled_abi_types () + #endif + } + +-/* Switch masks. */ +-#undef M +-#define M(NAME) OPTION_MASK_##NAME +-const int loongarch_switch_maskN_SWITCH_TYPES = { +- /* SW_SOFT_FLOAT */ M(FORCE_SOFTF), +- /* SW_SINGLE_FLOAT */ M(FORCE_F32), +- /* SW_DOUBLE_FLOAT */ M(FORCE_F64), +-}; +-#undef M +- + /* String processing. */ + static struct obstack msg_obstack; + #define APPEND_STRING(STR) obstack_grow (&msg_obstack, STR, strlen(STR)); +@@ -104,9 +96,10 @@ static int isa_fpu_compat_p (const struct loongarch_isa *set1, + const struct loongarch_isa *set2); + static int abi_compat_p (const struct loongarch_isa *isa, + struct loongarch_abi abi); +-static int abi_default_cpu_arch (struct loongarch_abi abi); ++static int abi_default_cpu_arch (struct loongarch_abi abi, ++ struct loongarch_isa *isa); + +-/* Checking configure-time defaults. */ ++/* Mandatory configure-time defaults. */ + #ifndef DEFAULT_ABI_BASE + #error missing definition of DEFAULT_ABI_BASE in ${tm_defines}. + #endif +@@ -119,21 +112,57 @@ static int abi_default_cpu_arch (struct loongarch_abi abi); + #error missing definition of DEFAULT_CPU_ARCH in ${tm_defines}. + #endif + +-#ifndef DEFAULT_ISA_EXT_FPU +-#error missing definition of DEFAULT_ISA_EXT_FPU in ${tm_defines}. ++/* Optional configure-time defaults. */ ++#ifdef DEFAULT_CPU_TUNE ++static int with_default_tune = 1; ++#else ++#define DEFAULT_CPU_TUNE -1 ++static int with_default_tune = 0; ++#endif ++ ++#ifdef DEFAULT_ISA_EXT_FPU ++static int with_default_fpu = 1; ++#else ++#define DEFAULT_ISA_EXT_FPU -1 ++static int with_default_fpu = 0; ++#endif ++ ++#ifdef DEFAULT_ISA_EXT_SIMD ++static int with_default_simd = 1; ++#else ++#define DEFAULT_ISA_EXT_SIMD -1 ++static int with_default_simd = 0; + #endif + +-/* Handle combinations of -m machine option values ++ ++/* Initialize loongarch_target from separate option variables. */ ++ ++void ++loongarch_init_target (struct loongarch_target *target, ++ int cpu_arch, int cpu_tune, int fpu, int simd, ++ int abi_base, int abi_ext, int cmodel) ++{ ++ if (!target) ++ return; ++ target->cpu_arch = cpu_arch; ++ target->cpu_tune = cpu_tune; ++ target->isa.fpu = fpu; ++ target->isa.simd = simd; ++ target->abi.base = abi_base; ++ target->abi.ext = abi_ext; ++ target->cmodel = cmodel; ++} ++ ++ ++/* Handle combinations of -m parameters + (see loongarch.opt and loongarch-opts.h). */ ++ + void + loongarch_config_target (struct loongarch_target *target, +- HOST_WIDE_INT opt_switches, +- int opt_arch, int opt_tune, int opt_fpu, +- int opt_abi_base, int opt_abi_ext, +- int opt_cmodel, int follow_multilib_list) ++ struct loongarch_flags *flags, ++ int follow_multilib_list_p) + { + struct loongarch_target t; +- + if (!target) + return; + +@@ -142,67 +171,63 @@ loongarch_config_target (struct loongarch_target *target, + obstack_init (&msg_obstack); + + struct { +- int arch, tune, fpu, abi_base, abi_ext, cmodel; ++ int arch, tune, fpu, simd, abi_base, abi_ext, cmodel, abi_flt; + } constrained = { +- M_OPT_ABSENT(opt_arch) ? 0 : 1, +- M_OPT_ABSENT(opt_tune) ? 0 : 1, +- M_OPT_ABSENT(opt_fpu) ? 0 : 1, +- M_OPT_ABSENT(opt_abi_base) ? 0 : 1, +- M_OPT_ABSENT(opt_abi_ext) ? 0 : 1, +- M_OPT_ABSENT(opt_cmodel) ? 0 : 1, ++ M_OPT_ABSENT (target->cpu_arch) ? 0 : 1, ++ M_OPT_ABSENT (target->cpu_tune) ? 0 : 1, ++ M_OPT_ABSENT (target->isa.fpu) ? 0 : 1, ++ M_OPT_ABSENT (target->isa.simd) ? 0 : 1, ++ M_OPT_ABSENT (target->abi.base) ? 0 : 1, ++ M_OPT_ABSENT (target->abi.ext) ? 0 : 1, ++ M_OPT_ABSENT (target->cmodel) ? 0 : 1, ++ M_OPT_ABSENT (target->abi.base) ? 0 : 1, + }; + +-#define on(NAME) ((loongarch_switch_mask(SW_##NAME) & opt_switches) \ +- && (on_switch = (SW_##NAME), 1)) +- int on_switch; +- + /* 1. Target ABI */ +- t.abi.base = constrained.abi_base ? opt_abi_base : DEFAULT_ABI_BASE; ++ if (constrained.abi_base) ++ t.abi.base = target->abi.base; ++ else ++ t.abi.base = DEFAULT_ABI_BASE; + +- t.abi.ext = constrained.abi_ext ? opt_abi_ext : DEFAULT_ABI_EXT; ++ t.abi.ext = constrained.abi_ext ? target->abi.ext : DEFAULT_ABI_EXT; + +- /* Extra switch handling. */ +- if (on (SOFT_FLOAT) || on (SINGLE_FLOAT) || on (DOUBLE_FLOAT)) ++ /* Process -m*-float flags */ ++ if (flags && !M_OPT_ABSENT (flags->flt)) + { +- switch (on_switch) +- { +- case SW_SOFT_FLOAT: +- opt_fpu = ISA_EXT_NOFPU; +- break; +- +- case SW_SINGLE_FLOAT: +- opt_fpu = ISA_EXT_FPU32; +- break; +- +- case SW_DOUBLE_FLOAT: +- opt_fpu = ISA_EXT_FPU64; +- break; ++ /* Modifying the original "target" here makes it easier to write the ++ t.isa.fpu assignment below, because otherwise there would be three ++ levels of precedence (-m*-float / -mfpu / -march) to be handled ++ (now the first two are merged). */ + +- default: +- gcc_unreachable(); +- } ++ target->isa.fpu = flags->flt; + constrained.fpu = 1; + + /* The target ISA is not ready yet, but (isa_required (t.abi) + + forced fpu) is enough for computing the forced base ABI. */ +- struct loongarch_isa default_isa = isa_required (t.abi); +- struct loongarch_isa force_isa = default_isa; +- struct loongarch_abi force_abi = t.abi; +- force_isa.fpu = opt_fpu; ++ ++ struct loongarch_isa force_isa = isa_required (t.abi); ++ force_isa.fpu = flags->flt; ++ ++ struct loongarch_abi force_abi; + force_abi.base = isa_default_abi (&force_isa).base; + +- if (constrained.abi_base && (t.abi.base != force_abi.base)) +- inform (UNKNOWN_LOCATION, +- "%<-m%s%> overrides %<-m%s=%s%>, adjusting ABI to %qs", +- loongarch_switch_stringson_switch, +- OPTSTR_ABI_BASE, loongarch_abi_base_stringst.abi.base, +- abi_str (force_abi)); ++ if (constrained.abi_base && constrained.abi_flt ++ && (t.abi.base != force_abi.base)) ++ { ++ force_abi.ext = t.abi.ext; ++ inform (UNKNOWN_LOCATION, ++ "%<-m%s%> overrides %<-m%s=%s%>, adjusting ABI to %qs", ++ flags->flt_str, OPTSTR_ABI_BASE, ++ loongarch_abi_base_stringst.abi.base, ++ abi_str (force_abi)); ++ } + + t.abi.base = force_abi.base; ++ constrained.abi_flt = 1; + } + + #ifdef LA_DISABLE_MULTILIB +- if (follow_multilib_list) ++ if (follow_multilib_list_p) + if (t.abi.base != DEFAULT_ABI_BASE || t.abi.ext != DEFAULT_ABI_EXT) + { + static const struct loongarch_abi default_abi +@@ -214,18 +239,22 @@ loongarch_config_target (struct loongarch_target *target, + #endif + + /* 2. Target CPU */ +- t.cpu_arch = constrained.arch ? opt_arch : DEFAULT_CPU_ARCH; ++ t.cpu_arch = constrained.arch ? target->cpu_arch : DEFAULT_CPU_ARCH; ++ ++ /* If cpu_tune is not set using neither -mtune nor --with-tune, ++ the current cpu_arch is used as its default. */ ++ t.cpu_tune = constrained.tune ? target->cpu_tune ++ : (constrained.arch ? target->cpu_arch : ++ (with_default_tune ? DEFAULT_CPU_TUNE : DEFAULT_CPU_ARCH)); + +- t.cpu_tune = constrained.tune ? opt_tune +- : (constrained.arch ? DEFAULT_CPU_ARCH : DEFAULT_CPU_TUNE); + ++ /* Handle -march/tune=native */ + #ifdef __loongarch__ + /* For native compilers, gather local CPU information + and fill the "CPU_NATIVE" index of arrays defined in + loongarch-cpu.c. */ + +- t.cpu_native = fill_native_cpu_config (t.cpu_arch == CPU_NATIVE, +- t.cpu_tune == CPU_NATIVE); ++ fill_native_cpu_config (&t); + + #else + if (t.cpu_arch == CPU_NATIVE) +@@ -239,17 +268,130 @@ loongarch_config_target (struct loongarch_target *target, + "-m" OPTSTR_TUNE "=" STR_CPU_NATIVE); + #endif + +- /* 3. Target ISA */ ++ /* Handle -march/tune=abi-default */ ++ if (t.cpu_tune == CPU_ABI_DEFAULT) ++ t.cpu_tune = abi_default_cpu_arch (t.abi, NULL); ++ ++ if (t.cpu_arch == CPU_ABI_DEFAULT) ++ { ++ t.cpu_arch = abi_default_cpu_arch (t.abi, &(t.isa)); ++ loongarch_cpu_default_isat.cpu_arch = t.isa; ++ } ++ ++ /* 3. Target base ISA */ + config_target_isa: + + /* Get default ISA from "-march" or its default value. */ +- t.isa = loongarch_cpu_default_isaLARCH_ACTUAL_ARCH; ++ t.isa = loongarch_cpu_default_isat.cpu_arch; + + /* Apply incremental changes. */ + /* "-march=native" overrides the default FPU type. */ +- t.isa.fpu = constrained.fpu ? opt_fpu : +- ((t.cpu_arch == CPU_NATIVE && constrained.arch) ? +- t.isa.fpu : DEFAULT_ISA_EXT_FPU); ++ ++ t.isa.fpu = constrained.fpu ? target->isa.fpu : ++ (constrained.arch ? t.isa.fpu : ++ (with_default_fpu ? DEFAULT_ISA_EXT_FPU : t.isa.fpu)); ++ ++ int simd_base = (constrained.arch ? t.isa.simd : ++ (with_default_simd ? DEFAULT_ISA_EXT_SIMD : t.isa.simd)); ++ ++ t.isa.simd = constrained.simd ? target->isa.simd : simd_base; ++ ++ /* If fallback_lsx is set, using -mno-lasx would cause ++ a fall-back to -msimd=lsx instead of -msimd=none. */ ++ ++ int fallback_lsx = 0; ++ if (t.isa.simd == ISA_EXT_SIMD_LSX || simd_base != ISA_EXT_NONE) ++ fallback_lsx = 1; ++ ++ /* apply -mno-lsx and -mno-lasx flags */ ++ if (flags) ++ for (int i = 0; i < 2; i++) ++ { ++ switch (SX_FLAG_TYPE (flags->sxi)) ++ { ++ case ISA_EXT_SIMD_LSX: ++ constrained.simd = 1; ++ ++ if (flags->sxi > 0) ++ fallback_lsx = 1; ++ ++ if (flags->sxi > 0 && t.isa.simd != ISA_EXT_SIMD_LASX) ++ t.isa.simd = ISA_EXT_SIMD_LSX; ++ else if (flags->sxi < 0) ++ t.isa.simd = ISA_EXT_NONE; ++ break; ++ ++ case ISA_EXT_SIMD_LASX: ++ constrained.simd = 1; ++ /* If -mlsx or simd=lsx (msimd or march-default) was not ++ involved, do not fall back to simd=lsx. */ ++ if (flags->sxi < 0 && t.isa.simd == ISA_EXT_SIMD_LASX) ++ t.isa.simd = fallback_lsx ? ISA_EXT_SIMD_LSX : ISA_EXT_NONE; ++ else if (flags->sxi > 0) ++ t.isa.simd = ISA_EXT_SIMD_LASX; ++ break; ++ ++ case 0: ++ break; ++ ++ default: ++ gcc_unreachable (); ++ } ++ } ++ ++ /* All SIMD extensions imply a 64-bit FPU: ++ - silently adjust t.isa.fpu to "fpu64" if it is unconstrained. ++ - warn if -msingle-float / -msoft-float is on, ++ then disable SIMD extensions (done in driver) ++ - abort if -mfpu=0 / -mfpu=32 is forced. */ ++ ++ if (t.isa.simd != ISA_EXT_NONE && t.isa.fpu != ISA_EXT_FPU64) ++ { ++ if (!constrained.fpu) ++ { ++ /* As long as the arch-default "t.isa.simd" is set to non-zero ++ for an element "t" in loongarch_cpu_default_isa, "t.isa.fpu" ++ should be set to "ISA_EXT_FPU64" accordingly. Thus reaching ++ here must be the result of forcing -mlsx/-mlasx explicitly. */ ++ gcc_assert (constrained.simd); ++ ++ inform (UNKNOWN_LOCATION, ++ "enabing %qs promotes %<%s%s%> to %<%s%s%>", ++ loongarch_isa_ext_stringst.isa.simd, ++ OPTSTR_ISA_EXT_FPU, loongarch_isa_ext_stringst.isa.fpu, ++ OPTSTR_ISA_EXT_FPU, loongarch_isa_ext_stringsISA_EXT_FPU64); ++ ++ t.isa.fpu = ISA_EXT_FPU64; ++ } ++ else if (flags && (flags->flt == ISA_EXT_NONE ++ || flags->flt == ISA_EXT_FPU32)) ++ { ++ if (constrained.simd) ++ inform (UNKNOWN_LOCATION, ++ "%qs is disabled by %<-m%s%>, because it requires %<%s%s%>", ++ loongarch_isa_ext_stringst.isa.simd, flags->flt_str, ++ OPTSTR_ISA_EXT_FPU, ++ loongarch_isa_ext_stringsISA_EXT_FPU64); ++ ++ t.isa.simd = ISA_EXT_NONE; ++ } ++ else ++ { ++ /* -mfpu=0 / -mfpu=32 is set. */ ++ if (constrained.simd) ++ fatal_error (UNKNOWN_LOCATION, ++ "%<-m%s=%s%> conflicts with %qs, " ++ "which requires %<%s%s%>", ++ OPTSTR_ISA_EXT_FPU, ++ loongarch_isa_ext_stringst.isa.fpu, ++ loongarch_isa_ext_stringst.isa.simd, ++ OPTSTR_ISA_EXT_FPU, ++ loongarch_isa_ext_stringsISA_EXT_FPU64); ++ ++ /* Same as above. */ ++ t.isa.simd = ISA_EXT_NONE; ++ } ++ } + + + /* 4. ABI-ISA compatibility */ +@@ -272,7 +414,7 @@ config_target_isa: + { + /* Base architecture can only be implied by -march, + so we adjust that first if it is not constrained. */ +- int fallback_arch = abi_default_cpu_arch (t.abi); ++ int fallback_arch = abi_default_cpu_arch (t.abi, NULL); + + if (t.cpu_arch == CPU_NATIVE) + warning (0, "your native CPU architecture (%qs) " +@@ -319,7 +461,7 @@ fatal: + if (abi_tmp.base != t.abi.base || abi_tmp.ext != t.abi.ext) + { + /* This flag is only set in the GCC driver. */ +- if (follow_multilib_list) ++ if (follow_multilib_list_p) + { + + /* Continue falling back until we find a feasible ABI type +@@ -360,7 +502,7 @@ fatal: + fallback: + t.abi = abi_tmp; + } +- else if (follow_multilib_list) ++ else if (follow_multilib_list_p) + { + if (!is_multilib_enabled (t.abi)) + { +@@ -375,7 +517,7 @@ fallback: + + + /* 5. Target code model */ +- t.cmodel = constrained.cmodel ? opt_cmodel : CMODEL_NORMAL; ++ t.cmodel = constrained.cmodel ? target->cmodel : CMODEL_NORMAL; + + switch (t.cmodel) + { +@@ -419,7 +561,7 @@ isa_default_abi (const struct loongarch_isa *isa) + abi.base = ABI_BASE_LP64F; + break; + +- case ISA_EXT_NOFPU: ++ case ISA_EXT_NONE: + if (isa->base == ISA_BASE_LA64V100) + abi.base = ABI_BASE_LP64S; + break; +@@ -459,7 +601,7 @@ isa_fpu_compat_p (const struct loongarch_isa *set1, + case ISA_EXT_FPU32: + return set1->fpu == ISA_EXT_FPU32 || set1->fpu == ISA_EXT_FPU64; + +- case ISA_EXT_NOFPU: ++ case ISA_EXT_NONE: + return 1; + + default: +@@ -483,16 +625,22 @@ abi_compat_p (const struct loongarch_isa *isa, struct loongarch_abi abi) + /* The behavior of this function should be consistent + with config.gcc. */ + static inline int +-abi_default_cpu_arch (struct loongarch_abi abi) ++abi_default_cpu_arch (struct loongarch_abi abi, ++ struct loongarch_isa *isa) + { +- switch (abi.base) +- { +- case ABI_BASE_LP64D: +- case ABI_BASE_LP64F: +- case ABI_BASE_LP64S: +- if (abi.ext == ABI_EXT_BASE) ++ static struct loongarch_isa tmp; ++ if (!isa) ++ isa = &tmp; ++ ++ if (abi.ext == ABI_EXT_BASE) ++ switch (abi.base) ++ { ++ case ABI_BASE_LP64D: ++ case ABI_BASE_LP64F: ++ case ABI_BASE_LP64S: ++ *isa = isa_required (abi); + return CPU_LOONGARCH64; +- } ++ } + gcc_unreachable (); + } + +@@ -521,7 +669,7 @@ isa_str (const struct loongarch_isa *isa, char separator) + APPEND_STRING (loongarch_isa_base_stringsisa->base) + APPEND1 (separator) + +- if (isa->fpu == ISA_EXT_NOFPU) ++ if (isa->fpu == ISA_EXT_NONE) + { + APPEND_STRING ("no" OPTSTR_ISA_EXT_FPU) + } +@@ -530,6 +678,18 @@ isa_str (const struct loongarch_isa *isa, char separator) + APPEND_STRING (OPTSTR_ISA_EXT_FPU) + APPEND_STRING (loongarch_isa_ext_stringsisa->fpu) + } ++ ++ switch (isa->simd) ++ { ++ case ISA_EXT_SIMD_LSX: ++ case ISA_EXT_SIMD_LASX: ++ APPEND1 (separator); ++ APPEND_STRING (loongarch_isa_ext_stringsisa->simd); ++ break; ++ ++ default: ++ gcc_assert (isa->simd == 0); ++ } + APPEND1 ('\0') + + /* Add more here. */ +@@ -542,18 +702,12 @@ arch_str (const struct loongarch_target *target) + { + if (target->cpu_arch == CPU_NATIVE) + { +- if (target->cpu_native == CPU_NATIVE) +- { +- /* Describe a native CPU with unknown PRID. */ +- const char* isa_string = isa_str (&target->isa, ','); +- APPEND_STRING ("PRID: 0x") +- APPEND_STRING (get_native_prid_str ()) +- APPEND_STRING (", ISA features: ") +- APPEND_STRING (isa_string) +- APPEND1 ('\0') +- } +- else +- APPEND_STRING (loongarch_cpu_stringstarget->cpu_native); ++ /* Describe a native CPU with unknown PRID. */ ++ const char* isa_string = isa_str (&target->isa, ','); ++ APPEND_STRING ("PRID: 0x") ++ APPEND_STRING (get_native_prid_str ()) ++ APPEND_STRING (", ISA features: ") ++ APPEND_STRING (isa_string) + } + else + APPEND_STRING (loongarch_cpu_stringstarget->cpu_arch); +@@ -594,3 +748,23 @@ multilib_enabled_abi_list () + + return XOBFINISH (&msg_obstack, const char *); + } ++ ++/* option status feedback for "gcc --help=target -Q" */ ++void ++loongarch_update_gcc_opt_status (struct loongarch_target *target, ++ struct gcc_options *opts, ++ struct gcc_options *opts_set) ++{ ++ (void) opts_set; ++ ++ /* status of -mabi */ ++ opts->x_la_opt_abi_base = target->abi.base; ++ ++ /* status of -march and -mtune */ ++ opts->x_la_opt_cpu_arch = target->cpu_arch; ++ opts->x_la_opt_cpu_tune = target->cpu_tune; ++ ++ /* status of -mfpu */ ++ opts->x_la_opt_fpu = target->isa.fpu; ++ opts->x_la_opt_simd = target->isa.simd; ++} +diff --git a/gcc/config/loongarch/loongarch-opts.h b/gcc/config/loongarch/loongarch-opts.h +index 3523a4cf7..e3f9b6f99 100644 +--- a/gcc/config/loongarch/loongarch-opts.h ++++ b/gcc/config/loongarch/loongarch-opts.h +@@ -21,24 +21,39 @@ along with GCC; see the file COPYING3. If not see + #ifndef LOONGARCH_OPTS_H + #define LOONGARCH_OPTS_H + ++#include "loongarch-def.h" + + /* Target configuration */ + extern struct loongarch_target la_target; + +-/* Switch masks */ +-extern const int loongarch_switch_mask; +- +-#include "loongarch-def.h" ++/* Flag status */ ++struct loongarch_flags { ++ int flt; const char* flt_str; ++#define SX_FLAG_TYPE(x) ((x) < 0 ? -(x) : (x)) ++ int sx2; ++}; + + #if !defined(IN_LIBGCC2) && !defined(IN_TARGET_LIBS) && !defined(IN_RTS) ++ ++/* Initialize loongarch_target from separate option variables. */ ++void ++loongarch_init_target (struct loongarch_target *target, ++ int cpu_arch, int cpu_tune, int fpu, int simd, ++ int abi_base, int abi_ext, int cmodel); ++ ++ + /* Handler for "-m" option combinations, + shared by the driver and the compiler proper. */ + void + loongarch_config_target (struct loongarch_target *target, +- HOST_WIDE_INT opt_switches, +- int opt_arch, int opt_tune, int opt_fpu, +- int opt_abi_base, int opt_abi_ext, +- int opt_cmodel, int follow_multilib_list); ++ struct loongarch_flags *flags, ++ int follow_multilib_list_p); ++ ++/* option status feedback for "gcc --help=target -Q" */ ++void ++loongarch_update_gcc_opt_status (struct loongarch_target *target, ++ struct gcc_options *opts, ++ struct gcc_options *opts_set); + #endif + + +@@ -50,11 +65,11 @@ loongarch_config_target (struct loongarch_target *target, + #define TARGET_CMODEL_LARGE (la_target.cmodel == CMODEL_LARGE) + #define TARGET_CMODEL_EXTREME (la_target.cmodel == CMODEL_EXTREME) + +-#define TARGET_HARD_FLOAT (la_target.isa.fpu != ISA_EXT_NOFPU) ++#define TARGET_HARD_FLOAT (la_target.isa.fpu != ISA_EXT_NONE) + #define TARGET_HARD_FLOAT_ABI (la_target.abi.base == ABI_BASE_LP64D \ + || la_target.abi.base == ABI_BASE_LP64F) + +-#define TARGET_SOFT_FLOAT (la_target.isa.fpu == ISA_EXT_NOFPU) ++#define TARGET_SOFT_FLOAT (la_target.isa.fpu == ISA_EXT_NONE) + #define TARGET_SOFT_FLOAT_ABI (la_target.abi.base == ABI_BASE_LP64S) + #define TARGET_SINGLE_FLOAT (la_target.isa.fpu == ISA_EXT_FPU32) + #define TARGET_SINGLE_FLOAT_ABI (la_target.abi.base == ABI_BASE_LP64F) +@@ -66,30 +81,16 @@ loongarch_config_target (struct loongarch_target *target, + || la_target.abi.base == ABI_BASE_LP64F \ + || la_target.abi.base == ABI_BASE_LP64S) + +-#define TARGET_ARCH_NATIVE (la_target.cpu_arch == CPU_NATIVE) +-#define LARCH_ACTUAL_ARCH (TARGET_ARCH_NATIVE \ +- ? (la_target.cpu_native < N_ARCH_TYPES \ +- ? (la_target.cpu_native) : (CPU_NATIVE)) \ +- : (la_target.cpu_arch)) ++#define ISA_HAS_LSX (la_target.isa.simd == ISA_EXT_SIMD_LSX \ ++ || la_target.isa.simd == ISA_EXT_SIMD_LASX) ++#define ISA_HAS_LASX (la_target.isa.simd == ISA_EXT_SIMD_LASX) + +-#define TARGET_TUNE_NATIVE (la_target.cpu_tune == CPU_NATIVE) +-#define LARCH_ACTUAL_TUNE (TARGET_TUNE_NATIVE \ +- ? (la_target.cpu_native < N_TUNE_TYPES \ +- ? (la_target.cpu_native) : (CPU_NATIVE)) \ +- : (la_target.cpu_tune)) + +-#define TARGET_ARCH_LOONGARCH64 (LARCH_ACTUAL_ARCH == CPU_LOONGARCH64) +-#define TARGET_ARCH_LA464 (LARCH_ACTUAL_ARCH == CPU_LA464) +- +-#define TARGET_TUNE_LOONGARCH64 (LARCH_ACTUAL_TUNE == CPU_LOONGARCH64) +-#define TARGET_TUNE_LA464 (LARCH_ACTUAL_TUNE == CPU_LA464) ++/* TARGET_ macros for use in *.md template conditionals */ ++#define TARGET_uARCH_LA464 (la_target.cpu_tune == CPU_LA464) + + /* Note: optimize_size may vary across functions, + while -mno-memcpy imposes a global constraint. */ + #define TARGET_DO_OPTIMIZE_BLOCK_MOVE_P loongarch_do_optimize_block_move_p() + +-#ifndef HAVE_AS_EXPLICIT_RELOCS +-#define HAVE_AS_EXPLICIT_RELOCS 0 +-#endif +- + #endif /* LOONGARCH_OPTS_H */ +diff --git a/gcc/config/loongarch/loongarch-str.h b/gcc/config/loongarch/loongarch-str.h +index 9f1b0989c..6b12754a3 100644 +--- a/gcc/config/loongarch/loongarch-str.h ++++ b/gcc/config/loongarch/loongarch-str.h +@@ -27,13 +27,14 @@ along with GCC; see the file COPYING3. If not see + #define OPTSTR_TUNE "tune" + + #define STR_CPU_NATIVE "native" ++#define STR_CPU_ABI_DEFAULT "abi-default" + #define STR_CPU_LOONGARCH64 "loongarch64" + #define STR_CPU_LA464 "la464" + + #define STR_ISA_BASE_LA64V100 "la64" + + #define OPTSTR_ISA_EXT_FPU "fpu" +-#define STR_ISA_EXT_NOFPU "none" ++#define STR_NONE "none" + #define STR_ISA_EXT_FPU0 "0" + #define STR_ISA_EXT_FPU32 "32" + #define STR_ISA_EXT_FPU64 "64" +@@ -42,6 +43,10 @@ along with GCC; see the file COPYING3. If not see + #define OPTSTR_SINGLE_FLOAT "single-float" + #define OPTSTR_DOUBLE_FLOAT "double-float" + ++#define OPTSTR_ISA_EXT_SIMD "simd" ++#define STR_ISA_EXT_LSX "lsx" ++#define STR_ISA_EXT_LASX "lasx" ++ + #define OPTSTR_ABI_BASE "abi" + #define STR_ABI_BASE_LP64D "lp64d" + #define STR_ABI_BASE_LP64F "lp64f" +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 41d344b82..bd774d4a9 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -2551,7 +2551,7 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + + if (flag_plt) + { +- switch (la_opt_cmodel) ++ switch (la_target.cmodel) + { + case CMODEL_NORMAL: + insn = emit_call_insn (gen_call_value_internal (v0, +@@ -2593,7 +2593,7 @@ loongarch_call_tls_get_addr (rtx sym, enum loongarch_symbol_type type, rtx v0) + { + rtx dest = gen_reg_rtx (Pmode); + +- switch (la_opt_cmodel) ++ switch (la_target.cmodel) + { + case CMODEL_NORMAL: + case CMODEL_MEDIUM: +@@ -6060,8 +6060,8 @@ loongarch_adjust_cost (rtx_insn *, int dep_type, rtx_insn *, int cost, + static int + loongarch_issue_rate (void) + { +- if ((unsigned long) LARCH_ACTUAL_TUNE < N_TUNE_TYPES) +- return loongarch_cpu_issue_rateLARCH_ACTUAL_TUNE; ++ if ((unsigned long) la_target.cpu_tune < N_TUNE_TYPES) ++ return loongarch_cpu_issue_ratela_target.cpu_tune; + else + return 1; + } +@@ -6072,8 +6072,8 @@ loongarch_issue_rate (void) + static int + loongarch_multipass_dfa_lookahead (void) + { +- if ((unsigned long) LARCH_ACTUAL_TUNE < N_ARCH_TYPES) +- return loongarch_cpu_multipass_dfa_lookaheadLARCH_ACTUAL_TUNE; ++ if ((unsigned long) la_target.cpu_tune < N_ARCH_TYPES) ++ return loongarch_cpu_multipass_dfa_lookaheadla_target.cpu_tune; + else + return 0; + } +@@ -6250,17 +6250,54 @@ loongarch_init_machine_status (void) + } + + static void +-loongarch_option_override_internal (struct gcc_options *opts) ++loongarch_cpu_option_override (struct loongarch_target *target, ++ struct gcc_options *opts, ++ struct gcc_options *opts_set) ++{ ++ /* alignments */ ++ if (opts->x_flag_align_functions && !opts->x_str_align_functions) ++ opts->x_str_align_functions ++ = loongarch_cpu_aligntarget->cpu_tune.function; ++ ++ if (opts->x_flag_align_labels && !opts->x_str_align_labels) ++ opts->x_str_align_labels = loongarch_cpu_aligntarget->cpu_tune.label; ++ ++ /* Set up parameters to be used in prefetching algorithm. */ ++ int simultaneous_prefetches ++ = loongarch_cpu_cachetarget->cpu_tune.simultaneous_prefetches; ++ ++ SET_OPTION_IF_UNSET (opts, opts_set, param_simultaneous_prefetches, ++ simultaneous_prefetches); ++ ++ SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_line_size, ++ loongarch_cpu_cachetarget->cpu_tune.l1d_line_size); ++ ++ SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_size, ++ loongarch_cpu_cachetarget->cpu_tune.l1d_size); ++ ++ SET_OPTION_IF_UNSET (opts, opts_set, param_l2_cache_size, ++ loongarch_cpu_cachetarget->cpu_tune.l2d_size); ++} ++ ++static void ++loongarch_option_override_internal (struct gcc_options *opts, ++ struct gcc_options *opts_set) + { + int i, regno, mode; + + if (flag_pic) + g_switch_value = 0; + ++ loongarch_init_target (&la_target, ++ la_opt_cpu_arch, la_opt_cpu_tune, la_opt_fpu, ++ la_opt_simd, la_opt_abi_base, la_opt_abi_ext, ++ la_opt_cmodel); ++ + /* Handle target-specific options: compute defaults/conflicts etc. */ +- loongarch_config_target (&la_target, la_opt_switches, +- la_opt_cpu_arch, la_opt_cpu_tune, la_opt_fpu, +- la_opt_abi_base, la_opt_abi_ext, la_opt_cmodel, 0); ++ loongarch_config_target (&la_target, NULL, 0); ++ ++ loongarch_update_gcc_opt_status (&la_target, opts, opts_set); ++ loongarch_cpu_option_override (&la_target, opts, opts_set); + + if (TARGET_ABI_LP64) + flag_pcc_struct_return = 0; +@@ -6269,33 +6306,13 @@ loongarch_option_override_internal (struct gcc_options *opts) + if (optimize_size) + loongarch_cost = &loongarch_rtx_cost_optimize_size; + else +- loongarch_cost = &loongarch_cpu_rtx_cost_dataLARCH_ACTUAL_TUNE; ++ loongarch_cost = &loongarch_cpu_rtx_cost_datala_target.cpu_tune; + + /* If the user hasn't specified a branch cost, use the processor's + default. */ + if (loongarch_branch_cost == 0) + loongarch_branch_cost = loongarch_cost->branch_cost; + +- /* Set up parameters to be used in prefetching algorithm. */ +- int simultaneous_prefetches +- = loongarch_cpu_cacheLARCH_ACTUAL_TUNE.simultaneous_prefetches; +- +- SET_OPTION_IF_UNSET (opts, &global_options_set, +- param_simultaneous_prefetches, +- simultaneous_prefetches); +- +- SET_OPTION_IF_UNSET (opts, &global_options_set, +- param_l1_cache_line_size, +- loongarch_cpu_cacheLARCH_ACTUAL_TUNE.l1d_line_size); +- +- SET_OPTION_IF_UNSET (opts, &global_options_set, +- param_l1_cache_size, +- loongarch_cpu_cacheLARCH_ACTUAL_TUNE.l1d_size); +- +- SET_OPTION_IF_UNSET (opts, &global_options_set, +- param_l2_cache_size, +- loongarch_cpu_cacheLARCH_ACTUAL_TUNE.l2d_size); +- + + /* Enable sw prefetching at -O3 and higher. */ + if (opts->x_flag_prefetch_loop_arrays < 0 +@@ -6303,12 +6320,6 @@ loongarch_option_override_internal (struct gcc_options *opts) + && !opts->x_optimize_size) + opts->x_flag_prefetch_loop_arrays = 1; + +- if (opts->x_flag_align_functions && !opts->x_str_align_functions) +- opts->x_str_align_functions = loongarch_cpu_alignLARCH_ACTUAL_TUNE.function; +- +- if (opts->x_flag_align_labels && !opts->x_str_align_labels) +- opts->x_str_align_labels = loongarch_cpu_alignLARCH_ACTUAL_TUNE.label; +- + if (TARGET_DIRECT_EXTERN_ACCESS && flag_shlib) + error ("%qs cannot be used for compiling a shared library", + "-mdirect-extern-access"); +@@ -6378,7 +6389,7 @@ loongarch_option_override_internal (struct gcc_options *opts) + static void + loongarch_option_override (void) + { +- loongarch_option_override_internal (&global_options); ++ loongarch_option_override_internal (&global_options, &global_options_set); + } + + /* Implement TARGET_CONDITIONAL_REGISTER_USAGE. */ +diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt +index 96c811c85..f96d32769 100644 +--- a/gcc/config/loongarch/loongarch.opt ++++ b/gcc/config/loongarch/loongarch.opt +@@ -24,22 +24,12 @@ + ; <http://www.gnu.org/licenses/>. + ; + +-; Variables (macros) that should be exported by loongarch.opt: +-; la_opt_switches, +-; la_opt_abi_base, la_opt_abi_ext, +-; la_opt_cpu_arch, la_opt_cpu_tune, +-; la_opt_fpu, +-; la_cmodel. +- + HeaderInclude + config/loongarch/loongarch-opts.h + + HeaderInclude + config/loongarch/loongarch-str.h + +-Variable +-HOST_WIDE_INT la_opt_switches = 0 +- + ; ISA related options + ;; Base ISA + Enum +@@ -49,14 +39,13 @@ Basic ISAs of LoongArch: + EnumValue + Enum(isa_base) String(la64) Value(ISA_BASE_LA64V100) + +- + ;; ISA extensions / adjustments + Enum + Name(isa_ext_fpu) Type(int) + FPU types of LoongArch: + + EnumValue +-Enum(isa_ext_fpu) String(none) Value(ISA_EXT_NOFPU) ++Enum(isa_ext_fpu) String(none) Value(ISA_EXT_NONE) + + EnumValue + Enum(isa_ext_fpu) String(32) Value(ISA_EXT_FPU32) +@@ -65,24 +54,48 @@ EnumValue + Enum(isa_ext_fpu) String(64) Value(ISA_EXT_FPU64) + + mfpu= +-Target RejectNegative Joined ToLower Enum(isa_ext_fpu) Var(la_opt_fpu) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined ToLower Enum(isa_ext_fpu) Var(la_opt_fpu) Init(M_OPT_UNSET) + -mfpu=FPU Generate code for the given FPU. + + mfpu=0 + Target RejectNegative Alias(mfpu=,none) + + msoft-float +-Target Driver RejectNegative Var(la_opt_switches) Mask(FORCE_SOFTF) Negative(msingle-float) ++Target Driver Defer Var(la_deferred_options) RejectNegative Negative(msingle-float) + Prevent the use of all hardware floating-point instructions. + + msingle-float +-Target Driver RejectNegative Var(la_opt_switches) Mask(FORCE_F32) Negative(mdouble-float) ++Target Driver Defer Var(la_deferred_options) RejectNegative Negative(mdouble-float) + Restrict the use of hardware floating-point instructions to 32-bit operations. + + mdouble-float +-Target Driver RejectNegative Var(la_opt_switches) Mask(FORCE_F64) Negative(msoft-float) ++Target Driver Defer Var(la_deferred_options) RejectNegative Negative(msoft-float) + Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations. + ++Enum ++Name(isa_ext_simd) Type(int) ++SIMD extension levels of LoongArch: ++ ++EnumValue ++Enum(isa_ext_simd) String(none) Value(ISA_EXT_NONE) ++ ++EnumValue ++Enum(isa_ext_simd) String(lsx) Value(ISA_EXT_SIMD_LSX) ++ ++EnumValue ++Enum(isa_ext_simd) String(lasx) Value(ISA_EXT_SIMD_LASX) ++ ++msimd= ++Target RejectNegative Joined ToLower Enum(isa_ext_simd) Var(la_opt_simd) Init(M_OPT_UNSET) ++-msimd=SIMD Generate code for the given SIMD extension. ++ ++mlsx ++Target Driver Defer Var(la_deferred_options) ++Enable LoongArch SIMD Extension (LSX, 128-bit). ++ ++mlasx ++Target Driver Defer Var(la_deferred_options) ++Enable LoongArch Advanced SIMD Extension (LASX, 256-bit). + + ;; Base target models (implies ISA & tune parameters) + Enum +@@ -92,6 +105,9 @@ LoongArch CPU types: + EnumValue + Enum(cpu_type) String(native) Value(CPU_NATIVE) + ++EnumValue ++Enum(cpu_type) String(abi-default) Value(CPU_ABI_DEFAULT) ++ + EnumValue + Enum(cpu_type) String(loongarch64) Value(CPU_LOONGARCH64) + +@@ -99,11 +115,11 @@ EnumValue + Enum(cpu_type) String(la464) Value(CPU_LA464) + + march= +-Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET) + -march=PROCESSOR Generate code for the given PROCESSOR ISA. + + mtune= +-Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_tune) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_tune) Init(M_OPT_UNSET) + -mtune=PROCESSOR Generate optimized code for PROCESSOR. + + +@@ -125,13 +141,13 @@ EnumValue + Enum(abi_base) String(lp64s) Value(ABI_BASE_LP64S) + + mabi= +-Target RejectNegative Joined ToLower Enum(abi_base) Var(la_opt_abi_base) Init(M_OPTION_NOT_SEEN) ++Target RejectNegative Joined ToLower Enum(abi_base) Var(la_opt_abi_base) Init(M_OPT_UNSET) + -mabi=BASEABI Generate code that conforms to the given BASEABI. + ++ + ;; ABI Extension + Variable +-int la_opt_abi_ext = M_OPTION_NOT_SEEN +- ++int la_opt_abi_ext = M_OPT_UNSET + + mbranch-cost= + Target RejectNegative Joined UInteger Var(loongarch_branch_cost) +@@ -189,7 +205,7 @@ EnumValue + Enum(cmodel) String(extreme) Value(CMODEL_EXTREME) + + mcmodel= +-Target RejectNegative Joined Enum(cmodel) Var(la_opt_cmodel) Init(CMODEL_NORMAL) ++Target RejectNegative Joined Enum(cmodel) Var(la_opt_cmodel) Init(M_OPT_UNSET) + Specify the code model. + + mdirect-extern-access +diff --git a/gcc/config/loongarch/t-linux b/gcc/config/loongarch/t-linux +index 136b27d0a..62a870b66 100644 +--- a/gcc/config/loongarch/t-linux ++++ b/gcc/config/loongarch/t-linux +@@ -23,7 +23,37 @@ MULTILIB_DIRNAMES = base/lp64d base/lp64f base/lp64s + # The GCC driver always gets all abi-related options on the command line. + # (see loongarch-driver.c:driver_get_normalized_m_opts) + comma=, +-MULTILIB_REQUIRED = $(subst $(comma), ,$(TM_MULTILIB_CONFIG)) ++MULTILIB_REQUIRED = $(foreach mlib,$(subst $(comma), ,$(TM_MULTILIB_CONFIG)),\ ++ $(firstword $(subst /, ,$(mlib)))) ++ ++SPECS = specs.install ++ ++# temporary self_spec when building libraries (e.g. libgcc) ++gen_mlib_spec = $(if $(word 2,$1),\ ++ %{$(firstword $1):$(patsubst %,-%,$(wordlist 2,$(words $1),$1))}) ++ ++# clean up the result of DRIVER_SELF_SPEC to avoid conflict ++lib_build_self_spec = %<march=* %<mtune=* %<mcmodel=* %<mfpu=* %<msimd=* ++ ++# append user-specified build options from --with-multilib-list ++lib_build_self_spec += $(foreach mlib,\ ++ $(subst $(comma), ,$(TM_MULTILIB_CONFIG)),\ ++ $(call gen_mlib_spec,$(subst /, ,$(mlib)))) ++ ++specs: specs.install ++ sed '/^*self_spec:$$/{ n;s/^$$/$(lib_build_self_spec)/g; }' $< > $@ ++ ++# Do some preparation before regression tests: ++# remove lib-build-specs / make symlinks for the toplevel multilib variant ++ ++LA_DEFAULT_MULTISUBDIR = $(shell $(GCC_FOR_TARGET) --print-multi-dir) ++.PHONY: remove-lib-specs ++check check-host check-target $(CHECK_TARGETS) $(lang_checks): remove-lib-specs ++remove-lib-specs: ++ -mv -f specs.install specs 2>/dev/null ++ -mv $(LA_DEFAULT_MULTISUBDIR)/* ./ ++ -mkdir -p ../$(target_noncanonical)/`dirname $(LA_DEFAULT_MULTISUBDIR)` ++ -$(LN_S) .. ../$(target_noncanonical)/$(LA_DEFAULT_MULTISUBDIR) + + # Multiarch + ifneq ($(call if_multiarch,yes),yes) +diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi +index 19d073256..1fc5f0bfa 100644 +--- a/gcc/doc/install.texi ++++ b/gcc/doc/install.texi +@@ -1173,7 +1173,7 @@ sysv, aix. + @itemx --without-multilib-list + Specify what multilibs to build. @var{list} is a comma separated list of + values, possibly consisting of a single value. Currently only implemented +-for aarch64*-*-*, arm*-*-*, loongarch64-*-*, riscv*-*-*, sh*-*-* and ++for aarch64*-*-*, arm*-*-*, loongarch*-*-*, riscv*-*-*, sh*-*-* and + x86-64-*-linux*. The accepted values and meaning for each target is given + below. + +@@ -1263,12 +1263,33 @@ profile. The union of these options is considered when specifying both + @end multitable + + @item loongarch*-*-* +-@var{list} is a comma-separated list of the following ABI identifiers: +-@code{lp64d/base} @code{lp64f/base} @code{lp64d/base}, where the +-@code{/base} suffix may be omitted, to enable their respective run-time +-libraries. If @var{list} is empty or @code{default}, +-or if @option{--with-multilib-list} is not specified, then the default ABI +-as specified by @option{--with-abi} or implied by @option{--target} is selected. ++@var{list} is a comma-separated list, with each of the element starting with ++the following ABI identifiers: @code{lp64d/base} @code{lp64f/base} ++@code{lp64d/base} (the @code{/base} suffix may be omitted) ++to enable their respective run-time libraries. ++ ++A suffix @code{/@var{arch}/@var{option}/@dots{}} may follow immediately ++after the ABI identifier to customize the compiler options for building the ++given set of libraries. @var{arch} denotes the architecture name recognized ++by the @option{-march=@var{arch}} compiler option, which acts as a basic target ++ISA configuration that can be adjusted using the subsequent @var{option} ++suffixes, where each @var{option} is a compiler option without a leading dash ++('-'). ++ ++If no such suffix is present for a given multilib variant, the ++configured value of @option{--with-multilib-default} is appended as a default ++suffix. If @option{--with-multilib-default} is not given, the default build ++option @option{-march=abi-default} is applied when building the variants ++without a suffix. ++ ++As a special case, @code{fixed} may be used in the position of @var{arch}, ++which means using the architecture configured with ++@option{--with-arch=@var{arch}}, or its default value (e.g. @code{loongarch64} ++for @code{loongarch64-*} targets). ++ ++If @var{list} is empty or @code{default}, or if @option{--with-multilib-list} ++is not specified, then only the default variant of the libraries are built, ++where the default ABI is implied by the configured target triplet. + + @item riscv*-*-* + @var{list} is a single ABI name. The target architecture must be either +@@ -1319,6 +1340,19 @@ If @option{--with-multilib-list} is not given, then only 32-bit and + 64-bit run-time libraries will be enabled. + @end table + ++@item --with-multilib-default ++On LoongArch targets, set the default build options for enabled multilibs ++without build options appended to their corresponding ++@option{--with-multilib-list} items. The format of this value is ++@code{/@var{arch}/@var{option}/@dots{}}, where @var{arch} is an ++architecture name recognized by @option{-march=@var{arch}} compiler option, ++and subsequent @var{option} suffixes are compiler options minus a leading ++dash ('-'). ++ ++Multiple @var{option}s may appear consecutively while @var{arch} may only ++appear in the beginning or be omitted (which means @option{-march=abi-default} ++is applied when building the libraries). ++ + @item --with-multilib-generator=@var{config} + Specify what multilibs to build. @var{config} is a semicolon separated list of + values, possibly consisting of a single value. Currently only implemented +@@ -1468,6 +1502,7 @@ x86-64, PowerPC, and SPARC@. + @itemx --with-abi=@var{abi} + @itemx --with-fpu=@var{type} + @itemx --with-float=@var{type} ++@itemx --with-simd=@var{type} + These configure options provide default values for the @option{-mschedule=}, + @option{-march=}, @option{-mtune=}, @option{-mabi=}, and @option{-mfpu=} + options and for @option{-mhard-float} or @option{-msoft-float}. As with +@@ -4489,8 +4524,7 @@ Uses @code{lp64s/base} ABI by default. + @end table + + @item loongarch64-linux-gnu +-Same as @code{loongarch64-linux-gnuf64}, but may be used with +-@option{--with-abi=*} to configure the default ABI type. ++Same as @code{loongarch64-linux-gnuf64} for legacy support. + @end table + + More information about LoongArch can be found at +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-initial-ada-support-on-linux.patch
Added
@@ -0,0 +1,397 @@ +From 7fa71be34052de9bdd9f7bdf625ceeaabc7f16f0 Mon Sep 17 00:00:00 2001 +From: Yang Yujie <yangyujie@loongson.cn> +Date: Tue, 5 Sep 2023 11:50:07 +0800 +Subject: PATCH 062/124 LoongArch: initial ada support on linux + +gcc/ada/ChangeLog: + + * Makefile.rtl: Add LoongArch support. + * libgnarl/s-linux__loongarch.ads: New file. + * libgnat/system-linux-loongarch.ads: New file. + +gcc/ChangeLog: + + * config/loongarch/loongarch.h (CC1_SPEC): Mark normalized + options passed from driver to gnat1 as explicit for multilib. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/ada/Makefile.rtl | 49 +++++++ + gcc/ada/libgnarl/s-linux__loongarch.ads | 134 +++++++++++++++++++ + gcc/ada/libgnat/system-linux-loongarch.ads | 145 +++++++++++++++++++++ + gcc/config/loongarch/loongarch.h | 4 +- + 4 files changed, 330 insertions(+), 2 deletions(-) + create mode 100644 gcc/ada/libgnarl/s-linux__loongarch.ads + create mode 100644 gcc/ada/libgnat/system-linux-loongarch.ads + +diff --git a/gcc/ada/Makefile.rtl b/gcc/ada/Makefile.rtl +index aaf853e3a..579645d95 100644 +--- a/gcc/ada/Makefile.rtl ++++ b/gcc/ada/Makefile.rtl +@@ -2195,6 +2195,55 @@ ifeq ($(strip $(filter-out cygwin% mingw32% pe,$(target_os))),) + LIBRARY_VERSION := $(LIB_VERSION) + endif + ++# LoongArch Linux ++ifeq ($(strip $(filter-out loongarch% linux%,$(target_cpu) $(target_os))),) ++ LIBGNAT_TARGET_PAIRS = \ ++ a-exetim.adb<libgnarl/a-exetim__posix.adb \ ++ a-exetim.ads<libgnarl/a-exetim__default.ads \ ++ a-intnam.ads<libgnarl/a-intnam__linux.ads \ ++ a-nallfl.ads<libgnat/a-nallfl__wraplf.ads \ ++ a-synbar.adb<libgnarl/a-synbar__posix.adb \ ++ a-synbar.ads<libgnarl/a-synbar__posix.ads \ ++ s-inmaop.adb<libgnarl/s-inmaop__posix.adb \ ++ s-intman.adb<libgnarl/s-intman__posix.adb \ ++ s-linux.ads<libgnarl/s-linux__loongarch.ads \ ++ s-mudido.adb<libgnarl/s-mudido__affinity.adb \ ++ s-osinte.ads<libgnarl/s-osinte__linux.ads \ ++ s-osinte.adb<libgnarl/s-osinte__posix.adb \ ++ s-osprim.adb<libgnat/s-osprim__posix.adb \ ++ s-taprop.adb<libgnarl/s-taprop__linux.adb \ ++ s-tasinf.ads<libgnarl/s-tasinf__linux.ads \ ++ s-tasinf.adb<libgnarl/s-tasinf__linux.adb \ ++ s-tpopsp.adb<libgnarl/s-tpopsp__tls.adb \ ++ s-taspri.ads<libgnarl/s-taspri__posix.ads \ ++ g-sercom.adb<libgnat/g-sercom__linux.adb \ ++ $(TRASYM_DWARF_UNIX_PAIRS) \ ++ $(GNATRTL_128BIT_PAIRS) \ ++ s-tsmona.adb<libgnat/s-tsmona__linux.adb \ ++ $(ATOMICS_TARGET_PAIRS) \ ++ $(ATOMICS_BUILTINS_TARGET_PAIRS) \ ++ system.ads<libgnat/system-linux-loongarch.ads ++ ++ TOOLS_TARGET_PAIRS = indepsw.adb<indepsw-gnu.adb ++ ++ EXTRA_GNATRTL_NONTASKING_OBJS += $(TRASYM_DWARF_UNIX_OBJS) ++ EXTRA_GNATRTL_NONTASKING_OBJS += $(GNATRTL_128BIT_OBJS) ++ EXTRA_GNATRTL_TASKING_OBJS = s-linux.o a-exetim.o ++ ++ EH_MECHANISM = -gcc ++ THREADSLIB = -lpthread ++ MISCLIB = -ldl ++ GNATLIB_SHARED = gnatlib-shared-dual ++ GMEM_LIB = gmemlib ++ LIBRARY_VERSION := $(LIB_VERSION) ++ # Temporarily disable strict alignment -- for some reason, it causes ++ # infinite loops during stack unwinding (libgcc) and indefinite hang ++ # in some futex system calls. ++ GNATLIBCFLAGS += -mno-strict-align ++ GNATLIBCFLAGS_FOR_C += -mno-strict-align ++endif ++ ++ + # Mips Linux + ifeq ($(strip $(filter-out mips% linux%,$(target_cpu) $(target_os))),) + LIBGNAT_TARGET_PAIRS = \ +diff --git a/gcc/ada/libgnarl/s-linux__loongarch.ads b/gcc/ada/libgnarl/s-linux__loongarch.ads +new file mode 100644 +index 000000000..9773ec0ad +--- /dev/null ++++ b/gcc/ada/libgnarl/s-linux__loongarch.ads +@@ -0,0 +1,134 @@ ++------------------------------------------------------------------------------ ++-- -- ++-- GNU ADA RUN-TIME LIBRARY (GNARL) COMPONENTS -- ++-- -- ++-- S Y S T E M . L I N U X -- ++-- -- ++-- S p e c -- ++-- -- ++-- Copyright (C) 2009-2023, Free Software Foundation, Inc. -- ++-- -- ++-- GNARL is free software; you can redistribute it and/or modify it under -- ++-- terms of the GNU General Public License as published by the Free Soft- -- ++-- ware Foundation; either version 3, or (at your option) any later ver- -- ++-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- ++-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- ++-- or FITNESS FOR A PARTICULAR PURPOSE. -- ++-- -- ++-- As a special exception under Section 7 of GPL version 3, you are granted -- ++-- additional permissions described in the GCC Runtime Library Exception, -- ++-- version 3.1, as published by the Free Software Foundation. -- ++-- -- ++-- You should have received a copy of the GNU General Public License and -- ++-- a copy of the GCC Runtime Library Exception along with this program; -- ++-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- ++-- <http://www.gnu.org/licenses/>. -- ++-- -- ++------------------------------------------------------------------------------ ++ ++-- This is the LoongArch version of this package ++ ++-- This package encapsulates cpu specific differences between implementations ++-- of GNU/Linux, in order to share s-osinte-linux.ads. ++ ++-- PLEASE DO NOT add any with-clauses to this package or remove the pragma ++-- Preelaborate. This package is designed to be a bottom-level (leaf) package ++ ++with Interfaces.C; ++with System.Parameters; ++ ++package System.Linux is ++ pragma Preelaborate; ++ ++ ---------- ++ -- Time -- ++ ---------- ++ ++ subtype int is Interfaces.C.int; ++ subtype long is Interfaces.C.long; ++ subtype suseconds_t is Interfaces.C.long; ++ type time_t is range -2 ** (System.Parameters.time_t_bits - 1) ++ .. 2 ** (System.Parameters.time_t_bits - 1) - 1; ++ subtype clockid_t is Interfaces.C.int; ++ ++ type timespec is record ++ tv_sec : time_t; ++ tv_nsec : long; ++ end record; ++ pragma Convention (C, timespec); ++ ++ type timeval is record ++ tv_sec : time_t; ++ tv_usec : suseconds_t; ++ end record; ++ pragma Convention (C, timeval); ++ ++ ----------- ++ -- Errno -- ++ ----------- ++ ++ EAGAIN : constant := 11; ++ EINTR : constant := 4; ++ EINVAL : constant := 22; ++ ENOMEM : constant := 12; ++ EPERM : constant := 1; ++ ETIMEDOUT : constant := 110; ++ ++ ------------- ++ -- Signals -- ++ ------------- ++ ++ SIGHUP : constant := 1; -- hangup ++ SIGINT : constant := 2; -- interrupt (rubout) ++ SIGQUIT : constant := 3; -- quit (ASCD FS) ++ SIGILL : constant := 4; -- illegal instruction (not reset) ++ SIGTRAP : constant := 5; -- trace trap (not reset) ++ SIGIOT : constant := 6; -- IOT instruction ++ SIGABRT : constant := 6; -- used by abort, replace SIGIOT in the future ++ SIGBUS : constant := 7; -- bus error ++ SIGFPE : constant := 8; -- floating point exception ++ SIGKILL : constant := 9; -- kill (cannot be caught or ignored) ++ SIGUSR1 : constant := 10; -- user defined signal 1 ++ SIGSEGV : constant := 11; -- segmentation violation ++ SIGUSR2 : constant := 12; -- user defined signal 2 ++ SIGPIPE : constant := 13; -- write on a pipe with no one to read it ++ SIGALRM : constant := 14; -- alarm clock ++ SIGTERM : constant := 15; -- software termination signal from kill ++ SIGSTKFLT : constant := 16; -- coprocessor stack fault (Linux) ++ SIGCLD : constant := 17; -- alias for SIGCHLD ++ SIGCHLD : constant := 17; -- child status change ++ SIGCONT : constant := 18; -- stopped process has been continued ++ SIGSTOP : constant := 19; -- stop (cannot be caught or ignored) ++ SIGTSTP : constant := 20; -- user stop requested from tty ++ SIGTTIN : constant := 21; -- background tty read attempted ++ SIGTTOU : constant := 22; -- background tty write attempted ++ SIGURG : constant := 23; -- urgent condition on IO channel ++ SIGXCPU : constant := 24; -- CPU time limit exceeded ++ SIGXFSZ : constant := 25; -- filesize limit exceeded ++ SIGVTALRM : constant := 26; -- virtual timer expired ++ SIGPROF : constant := 27; -- profiling timer expired ++ SIGWINCH : constant := 28; -- window size change ++ SIGPOLL : constant := 29; -- pollable event occurred ++ SIGIO : constant := 29; -- I/O now possible (4.2 BSD) ++ SIGPWR : constant := 30; -- power-fail restart ++ SIGSYS : constant := 31; -- bad system call ++ SIG32 : constant := 32; -- glibc internal signal ++ SIG33 : constant := 33; -- glibc internal signal ++ SIG34 : constant := 34; -- glibc internal signal ++ ++ -- These don't exist for Linux/LoongArch. The constants are present ++ -- so that we can continue to use a-intnam-linux.ads. ++ SIGLOST : constant := 0; -- File lock lost ++ SIGUNUSED : constant := 0; -- unused signal (GNU/Linux) ++ SIGEMT : constant := 0; -- EMT ++ ++ -- struct_sigaction offsets ++ ++ sa_handler_pos : constant := 0; ++ sa_mask_pos : constant := Standard'Address_Size / 8; ++ sa_flags_pos : constant := 128 + sa_mask_pos; ++ ++ SA_SIGINFO : constant := 16#04#; ++ SA_ONSTACK : constant := 16#08000000#; ++ ++end System.Linux; +diff --git a/gcc/ada/libgnat/system-linux-loongarch.ads b/gcc/ada/libgnat/system-linux-loongarch.ads +new file mode 100644 +index 000000000..735f67041 +--- /dev/null ++++ b/gcc/ada/libgnat/system-linux-loongarch.ads +@@ -0,0 +1,145 @@ ++------------------------------------------------------------------------------ ++-- -- ++-- GNAT RUN-TIME COMPONENTS -- ++-- -- ++-- S Y S T E M -- ++-- -- ++-- S p e c -- ++-- (GNU-Linux/LoongArch Version) -- ++-- -- ++-- Copyright (C) 1992-2023, Free Software Foundation, Inc. -- ++-- -- ++-- This specification is derived from the Ada Reference Manual for use with -- ++-- GNAT. The copyright notice above, and the license provisions that follow -- ++-- apply solely to the contents of the part following the private keyword. -- ++-- -- ++-- GNAT is free software; you can redistribute it and/or modify it under -- ++-- terms of the GNU General Public License as published by the Free Soft- -- ++-- ware Foundation; either version 3, or (at your option) any later ver- -- ++-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- ++-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- ++-- or FITNESS FOR A PARTICULAR PURPOSE. -- ++-- -- ++-- As a special exception under Section 7 of GPL version 3, you are granted -- ++-- additional permissions described in the GCC Runtime Library Exception, -- ++-- version 3.1, as published by the Free Software Foundation. -- ++-- -- ++-- You should have received a copy of the GNU General Public License and -- ++-- a copy of the GCC Runtime Library Exception along with this program; -- ++-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- ++-- <http://www.gnu.org/licenses/>. -- ++-- -- ++-- GNAT was originally developed by the GNAT team at New York University. -- ++-- Extensive contributions were provided by Ada Core Technologies Inc. -- ++-- -- ++------------------------------------------------------------------------------ ++ ++package System is ++ pragma Pure; ++ -- Note that we take advantage of the implementation permission to make ++ -- this unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada ++ -- 2005, this is Pure in any case (AI-362). ++ ++ pragma No_Elaboration_Code_All; ++ -- Allow the use of that restriction in units that WITH this unit ++ ++ type Name is (SYSTEM_NAME_GNAT); ++ System_Name : constant Name := SYSTEM_NAME_GNAT; ++ ++ -- System-Dependent Named Numbers ++ ++ Min_Int : constant := -2 ** (Standard'Max_Integer_Size - 1); ++ Max_Int : constant := 2 ** (Standard'Max_Integer_Size - 1) - 1; ++ ++ Max_Binary_Modulus : constant := 2 ** Standard'Max_Integer_Size; ++ Max_Nonbinary_Modulus : constant := 2 ** Integer'Size - 1; ++ ++ Max_Base_Digits : constant := Long_Long_Float'Digits; ++ Max_Digits : constant := Long_Long_Float'Digits; ++ ++ Max_Mantissa : constant := Standard'Max_Integer_Size - 1; ++ Fine_Delta : constant := 2.0 ** (-Max_Mantissa); ++ ++ Tick : constant := 0.000_001; ++ ++ -- Storage-related Declarations ++ ++ type Address is private; ++ pragma Preelaborable_Initialization (Address); ++ Null_Address : constant Address; ++ ++ Storage_Unit : constant := 8; ++ Word_Size : constant := Standard'Word_Size; ++ Memory_Size : constant := 2 ** Word_Size; ++ ++ -- Address comparison ++ ++ function "<" (Left, Right : Address) return Boolean; ++ function "<=" (Left, Right : Address) return Boolean; ++ function ">" (Left, Right : Address) return Boolean; ++ function ">=" (Left, Right : Address) return Boolean; ++ function "=" (Left, Right : Address) return Boolean; ++ ++ pragma Import (Intrinsic, "<"); ++ pragma Import (Intrinsic, "<="); ++ pragma Import (Intrinsic, ">"); ++ pragma Import (Intrinsic, ">="); ++ pragma Import (Intrinsic, "="); ++ ++ -- Other System-Dependent Declarations ++ ++ type Bit_Order is (High_Order_First, Low_Order_First); ++ Default_Bit_Order : constant Bit_Order := Low_Order_First; ++ pragma Warnings (Off, Default_Bit_Order); -- kill constant condition warning ++ ++ -- Priority-related Declarations (RM D.1) ++ ++ Max_Priority : constant Positive := 30; ++ Max_Interrupt_Priority : constant Positive := 31; ++ ++ subtype Any_Priority is Integer range 0 .. 31; ++ subtype Priority is Any_Priority range 0 .. 30; ++ subtype Interrupt_Priority is Any_Priority range 31 .. 31; ++ ++ Default_Priority : constant Priority := 15; ++ ++private ++ ++ type Address is mod Memory_Size; ++ Null_Address : constant Address := 0; ++ ++ -------------------------------------- ++ -- System Implementation Parameters -- ++ -------------------------------------- ++ ++ -- These parameters provide information about the target that is used ++ -- by the compiler. They are in the private part of System, where they ++ -- can be accessed using the special circuitry in the Targparm unit ++ -- whose source should be consulted for more detailed descriptions ++ -- of the individual switch values. ++ ++ Backend_Divide_Checks : constant Boolean := False; ++ Backend_Overflow_Checks : constant Boolean := True; ++ Command_Line_Args : constant Boolean := True; ++ Configurable_Run_Time : constant Boolean := False; ++ Denorm : constant Boolean := True; ++ Duration_32_Bits : constant Boolean := False; ++ Exit_Status_Supported : constant Boolean := True; ++ Machine_Overflows : constant Boolean := False; ++ Machine_Rounds : constant Boolean := True; ++ Preallocated_Stacks : constant Boolean := False; ++ Signed_Zeros : constant Boolean := True; ++ Stack_Check_Default : constant Boolean := False; ++ Stack_Check_Probes : constant Boolean := True; ++ Stack_Check_Limits : constant Boolean := False; ++ Support_Aggregates : constant Boolean := True; ++ Support_Composite_Assign : constant Boolean := True; ++ Support_Composite_Compare : constant Boolean := True; ++ Support_Long_Shifts : constant Boolean := True; ++ Always_Compatible_Rep : constant Boolean := False; ++ Suppress_Standard_Library : constant Boolean := False; ++ Use_Ada_Main_Program_Name : constant Boolean := False; ++ Frontend_Exceptions : constant Boolean := False; ++ ZCX_By_Default : constant Boolean := True; ++ ++end System; +diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h +index 0e35d4dec..e0c9c9439 100644 +--- a/gcc/config/loongarch/loongarch.h ++++ b/gcc/config/loongarch/loongarch.h +@@ -83,9 +83,9 @@ along with GCC; see the file COPYING3. If not see + /* CC1_SPEC is the set of arguments to pass to the compiler proper. */ + + #undef CC1_SPEC +-#define CC1_SPEC "\ ++#define CC1_SPEC "%{,ada:-gnatea} %{m*} \ + %{G*} \ +-%(subtarget_cc1_spec)" ++%(subtarget_cc1_spec) %{,ada:-gnatez}" + + /* Preprocessor specs. */ + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-support-loongarch-elf-target.patch
Added
@@ -0,0 +1,152 @@ +From 71cfcadb647026ced3c99688793a2f8e5d5f0039 Mon Sep 17 00:00:00 2001 +From: Yang Yujie <yangyujie@loongson.cn> +Date: Fri, 30 Jun 2023 17:07:59 +0800 +Subject: PATCH 061/124 LoongArch: support loongarch*-elf target + +gcc/ChangeLog: + + * config.gcc: add loongarch*-elf target. + * config/loongarch/elf.h: New file. + Link against newlib by default. + +libgcc/ChangeLog: + + * config.host: add loongarch*-elf target. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config.gcc | 15 ++++++++++- + gcc/config/loongarch/elf.h | 51 ++++++++++++++++++++++++++++++++++++++ + libgcc/config.host | 9 +++++-- + 3 files changed, 72 insertions(+), 3 deletions(-) + create mode 100644 gcc/config/loongarch/elf.h + +diff --git a/gcc/config.gcc b/gcc/config.gcc +index 16bbaea45..61d81d8d8 100644 +--- a/gcc/config.gcc ++++ b/gcc/config.gcc +@@ -2519,6 +2519,18 @@ loongarch*-*-linux*) + gcc_cv_initfini_array=yes + ;; + ++loongarch*-*-elf*) ++ tm_file="elfos.h newlib-stdint.h ${tm_file}" ++ tm_file="${tm_file} loongarch/elf.h loongarch/linux.h" ++ tmake_file="${tmake_file} loongarch/t-linux" ++ gnu_ld=yes ++ gas=yes ++ ++ # For .init_array support. The configure script cannot always ++ # automatically detect that GAS supports it, yet we require it. ++ gcc_cv_initfini_array=yes ++ ;; ++ + mips*-*-netbsd*) # NetBSD/mips, either endian. + target_cpu_default="MASK_ABICALLS" + tm_file="elfos.h ${tm_file} mips/elf.h ${nbsd_tm_file} mips/netbsd.h" +@@ -5006,8 +5018,9 @@ case "${target}" in + esac + + case ${target} in +- *-linux-gnu*) triplet_os="linux-gnu";; ++ *-linux-gnu*) triplet_os="linux-gnu";; + *-linux-musl*) triplet_os="linux-musl";; ++ *-elf*) triplet_os="elf";; + *) + echo "Unsupported target ${target}." 1>&2 + exit 1 +diff --git a/gcc/config/loongarch/elf.h b/gcc/config/loongarch/elf.h +new file mode 100644 +index 000000000..523d5c756 +--- /dev/null ++++ b/gcc/config/loongarch/elf.h +@@ -0,0 +1,51 @@ ++/* Definitions for LoongArch ELF-based systems. ++ Copyright (C) 2023 Free Software Foundation, Inc. ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 3, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING3. If not see ++<http://www.gnu.org/licenses/>. */ ++ ++/* Define the size of the wide character type. */ ++#undef WCHAR_TYPE ++#define WCHAR_TYPE "int" ++ ++#undef WCHAR_TYPE_SIZE ++#define WCHAR_TYPE_SIZE 32 ++ ++ ++/* GNU-specific SPEC definitions. */ ++#define GNU_USER_LINK_EMULATION "elf" ABI_GRLEN_SPEC "loongarch" ++ ++#undef GNU_USER_TARGET_LINK_SPEC ++#define GNU_USER_TARGET_LINK_SPEC \ ++ "%{shared} -m " GNU_USER_LINK_EMULATION ++ ++ ++/* Link against Newlib libraries, because the ELF backend assumes Newlib. ++ Handle the circular dependence between libc and libgloss. */ ++#undef LIB_SPEC ++#define LIB_SPEC "--start-group -lc %{!specs=nosys.specs:-lgloss} --end-group" ++ ++#undef LINK_SPEC ++#define LINK_SPEC GNU_USER_TARGET_LINK_SPEC ++ ++#undef STARTFILE_SPEC ++#define STARTFILE_SPEC "crt0%O%s crtbegin%O%s" ++ ++#undef ENDFILE_SPEC ++#define ENDFILE_SPEC "crtend%O%s" ++ ++#undef SUBTARGET_CC1_SPEC ++#define SUBTARGET_CC1_SPEC "%{profile:-p}" +diff --git a/libgcc/config.host b/libgcc/config.host +index 8c56fcae5..dc12d646c 100644 +--- a/libgcc/config.host ++++ b/libgcc/config.host +@@ -138,7 +138,7 @@ hppa*-*-*) + lm32*-*-*) + cpu_type=lm32 + ;; +-loongarch*-*-*) ++loongarch*-*) + cpu_type=loongarch + tmake_file="loongarch/t-loongarch" + if test "${libgcc_cv_loongarch_hard_float}" = yes; then +@@ -942,7 +942,7 @@ lm32-*-uclinux*) + extra_parts="$extra_parts crtbegin.o crtendS.o crtbeginT.o" + tmake_file="lm32/t-lm32 lm32/t-uclinux t-libgcc-pic t-softfp-sfdf t-softfp" + ;; +-loongarch*-*-linux*) ++loongarch*-linux*) + extra_parts="$extra_parts crtfastmath.o" + tmake_file="${tmake_file} t-crtfm loongarch/t-crtstuff" + case ${host} in +@@ -952,6 +952,11 @@ loongarch*-*-linux*) + esac + md_unwind_header=loongarch/linux-unwind.h + ;; ++loongarch*-elf*) ++ extra_parts="$extra_parts crtfastmath.o" ++ tmake_file="${tmake_file} t-crtfm loongarch/t-crtstuff" ++ tmake_file="${tmake_file} t-slibgcc-libgcc" ++ ;; + m32r-*-elf*) + tmake_file="$tmake_file m32r/t-m32r t-fdpbit" + extra_parts="$extra_parts crtinit.o crtfini.o" +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-testsuite-Disable-stack-protector-for-some.patch
Added
@@ -0,0 +1,65 @@ +From 3bbaedb0f20b52bc276f40b6016becd2c4e66276 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Fri, 3 Mar 2023 16:32:41 +0800 +Subject: PATCH 038/124 LoongArch: testsuite: Disable stack protector for + some tests + +Stack protector will affect stack layout and break the expectation of +these tests, causing test failures if GCC is configured with +--enable-default-ssp. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/prolog-opt.c (dg-options): Add + -fno-stack-protector. + * gcc.target/loongarch/stack-check-cfa-1.c (dg-options): + Likewise. + * gcc.target/loongarch/stack-check-cfa-2.c (dg-options): + Likewise. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/testsuite/gcc.target/loongarch/prolog-opt.c | 2 +- + gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c | 2 +- + gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c | 2 +- + 3 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/gcc/testsuite/gcc.target/loongarch/prolog-opt.c b/gcc/testsuite/gcc.target/loongarch/prolog-opt.c +index 0470a1f1e..e6a642633 100644 +--- a/gcc/testsuite/gcc.target/loongarch/prolog-opt.c ++++ b/gcc/testsuite/gcc.target/loongarch/prolog-opt.c +@@ -1,7 +1,7 @@ + /* Test that LoongArch backend stack drop operation optimized. */ + + /* { dg-do compile } */ +-/* { dg-options "-O2 -mabi=lp64d" } */ ++/* { dg-options "-O2 -mabi=lp64d -fno-stack-protector" } */ + /* { dg-final { scan-assembler "addi.d\t\\\$r3,\\\$r3,-16" } } */ + + extern int printf (char *, ...); +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c +index f0c6877fc..3533fe7b6 100644 +--- a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-1.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16 -funwind-tables" } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16 -funwind-tables -fno-stack-protector" } */ + /* { dg-require-effective-target supports_stack_clash_protection } */ + /* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ + +diff --git a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c +index c6e07bc56..e5e711105 100644 +--- a/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c ++++ b/gcc/testsuite/gcc.target/loongarch/stack-check-cfa-2.c +@@ -1,5 +1,5 @@ + /* { dg-do compile } */ +-/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16 -funwind-tables" } */ ++/* { dg-options "-O2 -fstack-clash-protection --param stack-clash-protection-guard-size=16 -funwind-tables -fno-stack-protector" } */ + /* { dg-require-effective-target supports_stack_clash_protection } */ + /* { dg-skip-if "" { *-*-* } { "-fstack-check" } { "" } } */ + +-- +2.33.0 +
View file
_service:tar_scm:LoongArch-testsuite-refine-__tls_get_addr-tests-with.patch
Added
@@ -0,0 +1,159 @@ +From e34afad69acd5b0bd19aef9f6225ca38aa294193 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 24 Aug 2022 19:34:47 +0800 +Subject: PATCH 015/124 LoongArch: testsuite: refine __tls_get_addr tests + with tls_native + +If GCC is not built with a working linker for the target (developers +occansionally build such a "minimal" GCC for testing and debugging), +TLS will be emulated and __tls_get_addr won't be used. Refine those +tests depending on __tls_get_addr with tls_native to avoid test +failures. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/func-call-medium-1.c: Refine test + depending on __tls_get_addr with { target tls_native }. + * gcc.target/loongarch/func-call-medium-2.c: Likewise. + * gcc.target/loongarch/func-call-medium-3.c: Likewise. + * gcc.target/loongarch/func-call-medium-4.c: Likewise. + * gcc.target/loongarch/func-call-medium-5.c: Likewise. + * gcc.target/loongarch/func-call-medium-6.c: Likewise. + * gcc.target/loongarch/func-call-medium-7.c: Likewise. + * gcc.target/loongarch/func-call-medium-8.c: Likewise. + * gcc.target/loongarch/tls-gd-noplt.c: Likewise. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c | 2 +- + gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c | 2 +- + gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c | 2 +- + gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c | 2 +- + gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c | 2 +- + gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c | 2 +- + gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c | 2 +- + gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c | 3 ++- + gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c | 2 +- + 9 files changed, 10 insertions(+), 9 deletions(-) + +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c +index 276d73e5e..6339e832f 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-1.c +@@ -3,7 +3,7 @@ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*la\.global\t.*f\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ +-/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" { target tls_native } } } */ + + extern void g (void); + void +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c +index 237821c06..a53e75e0b 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-2.c +@@ -3,7 +3,7 @@ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*la\.local\t.*f\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ +-/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" { target tls_native } } } */ + + extern void g (void); + void +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c +index 9a6e16103..0da7bf98e 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-3.c +@@ -3,7 +3,7 @@ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*la\.global\t.*f\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ +-/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" { target tls_native } } } */ + + extern void g (void); + void +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c +index 2577e3452..0219688ae 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-4.c +@@ -3,7 +3,7 @@ + /* { dg-final { scan-assembler "test:.*la\.global\t.*g\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*la\.local\t.*f\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*la\.local\t.*l\n\tjirl" } } */ +-/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" } } */ ++/* { dg-final { scan-assembler "test3:.*la\.global\t.*\_\_tls\_get\_addr" { target tls_native } } } */ + + extern void g (void); + void +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c +index d70b6ea46..8a47b5afc 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c +@@ -3,7 +3,7 @@ + /* { dg-final { scan-assembler "test:.*pcalau12i.*%pc_hi20\\(g\\)\n\tjirl.*pc_lo12\\(g\\)" } } */ + /* { dg-final { scan-assembler "test1:.*pcalau12i.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */ + /* { dg-final { scan-assembler "test2:.*pcalau12i.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ +-/* { dg-final { scan-assembler "test3:.*pcalau12i.*%pc_hi20\\(__tls_get_addr\\)\n\t.*\n\tjirl.*%pc_lo12\\(__tls_get_addr\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%pc_hi20\\(__tls_get_addr\\)\n\t.*\n\tjirl.*%pc_lo12\\(__tls_get_addr\\)" { target tls_native } } } */ + + extern void g (void); + +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c +index f963a9944..1e75e60e0 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c +@@ -3,7 +3,7 @@ + /* { dg-final { scan-assembler "test:.*pcalau12i.*%pc_hi20\\(g\\)\n\tjirl.*pc_lo12\\(g\\)" } } */ + /* { dg-final { scan-assembler "test1:.*pcalau12i.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */ + /* { dg-final { scan-assembler "test2:.*pcalau12i.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ +-/* { dg-final { scan-assembler "test3:.*pcalau12i.*%pc_hi20\\(__tls_get_addr\\)\n\t.*\n\tjirl.*%pc_lo12\\(__tls_get_addr\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%pc_hi20\\(__tls_get_addr\\)\n\t.*\n\tjirl.*%pc_lo12\\(__tls_get_addr\\)" { target tls_native } } } */ + + extern void g (void); + +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c +index f2818b2da..9e89085ca 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c +@@ -3,7 +3,7 @@ + /* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%got_pc_hi20\\(f\\)\n\tld\.d\t.*%got_pc_lo12\\(f\\)\n\tjirl" } } */ + /* { dg-final { scan-assembler "test2:.*pcalau12i\t.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ +-/* { dg-final { scan-assembler "test3:.*pcalau12i.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" { target tls_native } } } */ + + + extern void g (void); +diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c +index 7fa873d84..fde9c6e0e 100644 +--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c ++++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c +@@ -3,7 +3,8 @@ + /* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */ + /* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */ + /* { dg-final { scan-assembler "test2:.*pcalau12i\t.*%pc_hi20\\(l\\)\n\tjirl.*%pc_lo12\\(l\\)" } } */ +-/* { dg-final { scan-assembler "test3:.*pcalau12i.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" { target tls_native } } } */ ++/* { dg-final { scan-assembler "test3:.*pcalau12i.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" { target tls_native } } } */ + + extern void g (void); + +diff --git a/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c b/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c +index 375663286..9432c477e 100644 +--- a/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c ++++ b/gcc/testsuite/gcc.target/loongarch/tls-gd-noplt.c +@@ -1,6 +1,6 @@ + /* { dg-do compile } */ + /* { dg-options "-O0 -fno-plt -mcmodel=normal -mexplicit-relocs" } */ +-/* { dg-final { scan-assembler "pcalau12i\t.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" } } */ ++/* { dg-final { scan-assembler "pcalau12i\t.*%got_pc_hi20\\(__tls_get_addr\\)\n\tld\.d.*%got_pc_lo12\\(__tls_get_addr\\)" { target tls_native } } } */ + + __attribute__ ((tls_model ("global-dynamic"))) __thread int a; + +-- +2.33.0 +
View file
_service:tar_scm:Loongarch-Fix-plugin-header-missing-install.patch
Added
@@ -0,0 +1,36 @@ +From ad4371f43e86f7cfe6b543926b2f587a30a8e32f Mon Sep 17 00:00:00 2001 +From: Guo Jie <guojie@loongson.cn> +Date: Wed, 16 Aug 2023 09:48:22 +0800 +Subject: PATCH 049/124 Loongarch: Fix plugin header missing install. + +gcc/ChangeLog: + + * config/loongarch/t-loongarch: Add loongarch-driver.h into + TM_H. Add loongarch-def.h and loongarch-tune.h into + OPTIONS_H_EXTRA. + +Co-authored-by: Lulu Cheng <chenglulu@loongson.cn> +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/t-loongarch | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/gcc/config/loongarch/t-loongarch b/gcc/config/loongarch/t-loongarch +index 6d6e3435d..e73f4f437 100644 +--- a/gcc/config/loongarch/t-loongarch ++++ b/gcc/config/loongarch/t-loongarch +@@ -16,6 +16,10 @@ + # along with GCC; see the file COPYING3. If not see + # <http://www.gnu.org/licenses/>. + ++TM_H += $(srcdir)/config/loongarch/loongarch-driver.h ++OPTIONS_H_EXTRA += $(srcdir)/config/loongarch/loongarch-def.h \ ++ $(srcdir)/config/loongarch/loongarch-tune.h ++ + # Canonical target triplet from config.gcc + LA_MULTIARCH_TRIPLET = $(patsubst LA_MULTIARCH_TRIPLET=%,%,$\ + $(filter LA_MULTIARCH_TRIPLET=%,$(tm_defines))) +-- +2.33.0 +
View file
_service:tar_scm:libffi-Backport-of-LoongArch-support-for-libffi.patch
Added
@@ -0,0 +1,1214 @@ +From aa12adeff7027bff4d03c61f982eb8bbb34f6937 Mon Sep 17 00:00:00 2001 +From: Lulu Cheng <chenglulu@loongson.cn> +Date: Tue, 22 Aug 2023 19:56:21 +0800 +Subject: PATCH 050/124 libffi: Backport of LoongArch support for libffi. + +This is a backport of <https://github.com/libffi/libffi/commit/f259a6f6de>, +and contains modifications to commit 5a4774cd4d, as well as the LoongArch +schema portion of commit ee22ecbd11. This is needed for libgo. + +libffi/ChangeLog: + + PR libffi/108682 + * configure.host: Add LoongArch support. + * Makefile.am: Likewise. + * Makefile.in: Regenerate. + * src/loongarch64/ffi.c: New file. + * src/loongarch64/ffitarget.h: New file. + * src/loongarch64/sysv.S: New file. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + libffi/Makefile.am | 4 +- + libffi/Makefile.in | 25 +- + libffi/configure.host | 5 + + libffi/src/loongarch64/ffi.c | 621 +++++++++++++++++++++++++++++ + libffi/src/loongarch64/ffitarget.h | 82 ++++ + libffi/src/loongarch64/sysv.S | 327 +++++++++++++++ + 6 files changed, 1058 insertions(+), 6 deletions(-) + create mode 100644 libffi/src/loongarch64/ffi.c + create mode 100644 libffi/src/loongarch64/ffitarget.h + create mode 100644 libffi/src/loongarch64/sysv.S + +diff --git a/libffi/Makefile.am b/libffi/Makefile.am +index c6d6f849c..2259ddb75 100644 +--- a/libffi/Makefile.am ++++ b/libffi/Makefile.am +@@ -139,7 +139,7 @@ noinst_HEADERS = src/aarch64/ffitarget.h src/aarch64/internal.h \ + src/sparc/internal.h src/tile/ffitarget.h src/vax/ffitarget.h \ + src/x86/ffitarget.h src/x86/internal.h src/x86/internal64.h \ + src/x86/asmnames.h src/xtensa/ffitarget.h src/dlmalloc.c \ +- src/kvx/ffitarget.h ++ src/kvx/ffitarget.h src/loongarch64/ffitarget.h + + EXTRA_libffi_la_SOURCES = src/aarch64/ffi.c src/aarch64/sysv.S \ + src/aarch64/win64_armasm.S src/alpha/ffi.c src/alpha/osf.S \ +@@ -169,7 +169,7 @@ EXTRA_libffi_la_SOURCES = src/aarch64/ffi.c src/aarch64/sysv.S \ + src/x86/ffiw64.c src/x86/win64.S src/x86/ffi64.c \ + src/x86/unix64.S src/x86/sysv_intel.S src/x86/win64_intel.S \ + src/xtensa/ffi.c src/xtensa/sysv.S src/kvx/ffi.c \ +- src/kvx/sysv.S ++ src/kvx/sysv.S src/loongarch64/ffi.c src/loongarch64/sysv.S + + TARGET_OBJ = @TARGET_OBJ@ + libffi_la_LIBADD = $(TARGET_OBJ) +diff --git a/libffi/Makefile.in b/libffi/Makefile.in +index 5524a6a57..1d936b5c8 100644 +--- a/libffi/Makefile.in ++++ b/libffi/Makefile.in +@@ -550,7 +550,7 @@ noinst_HEADERS = src/aarch64/ffitarget.h src/aarch64/internal.h \ + src/sparc/internal.h src/tile/ffitarget.h src/vax/ffitarget.h \ + src/x86/ffitarget.h src/x86/internal.h src/x86/internal64.h \ + src/x86/asmnames.h src/xtensa/ffitarget.h src/dlmalloc.c \ +- src/kvx/ffitarget.h ++ src/kvx/ffitarget.h src/loongarch64/ffitarget.h + + EXTRA_libffi_la_SOURCES = src/aarch64/ffi.c src/aarch64/sysv.S \ + src/aarch64/win64_armasm.S src/alpha/ffi.c src/alpha/osf.S \ +@@ -580,7 +580,7 @@ EXTRA_libffi_la_SOURCES = src/aarch64/ffi.c src/aarch64/sysv.S \ + src/x86/ffiw64.c src/x86/win64.S src/x86/ffi64.c \ + src/x86/unix64.S src/x86/sysv_intel.S src/x86/win64_intel.S \ + src/xtensa/ffi.c src/xtensa/sysv.S src/kvx/ffi.c \ +- src/kvx/sysv.S ++ src/kvx/sysv.S src/loongarch64/ffi.c src/loongarch64/sysv.S + + libffi_la_LIBADD = $(TARGET_OBJ) + libffi_convenience_la_SOURCES = $(libffi_la_SOURCES) +@@ -1074,6 +1074,16 @@ src/kvx/ffi.lo: src/kvx/$(am__dirstamp) \ + src/kvx/$(DEPDIR)/$(am__dirstamp) + src/kvx/sysv.lo: src/kvx/$(am__dirstamp) \ + src/kvx/$(DEPDIR)/$(am__dirstamp) ++src/loongarch64/$(am__dirstamp): ++ @$(MKDIR_P) src/loongarch64 ++ @: > src/loongarch64/$(am__dirstamp) ++src/loongarch64/$(DEPDIR)/$(am__dirstamp): ++ @$(MKDIR_P) src/loongarch64/$(DEPDIR) ++ @: > src/loongarch64/$(DEPDIR)/$(am__dirstamp) ++src/loongarch64/ffi.lo: src/loongarch64/$(am__dirstamp) \ ++ src/loongarch64/$(DEPDIR)/$(am__dirstamp) ++src/loongarch64/sysv.lo: src/loongarch64/$(am__dirstamp) \ ++ src/loongarch64/$(DEPDIR)/$(am__dirstamp) + + libffi.la: $(libffi_la_OBJECTS) $(libffi_la_DEPENDENCIES) $(EXTRA_libffi_la_DEPENDENCIES) + $(AM_V_CCLD)$(libffi_la_LINK) -rpath $(toolexeclibdir) $(libffi_la_OBJECTS) $(libffi_la_LIBADD) $(LIBS) +@@ -1107,6 +1117,8 @@ mostlyclean-compile: + -rm -f src/ia64/*.lo + -rm -f src/kvx/*.$(OBJEXT) + -rm -f src/kvx/*.lo ++ -rm -f src/loongarch64/*.$(OBJEXT) ++ -rm -f src/loongarch64/*.lo + -rm -f src/m32r/*.$(OBJEXT) + -rm -f src/m32r/*.lo + -rm -f src/m68k/*.$(OBJEXT) +@@ -1182,6 +1194,8 @@ distclean-compile: + @AMDEP_TRUE@@am__include@ @am__quote@src/ia64/$(DEPDIR)/unix.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@src/kvx/$(DEPDIR)/ffi.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@src/kvx/$(DEPDIR)/sysv.Plo@am__quote@ ++@AMDEP_TRUE@@am__include@ @am__quote@src/loongarch64/$(DEPDIR)/ffi.Plo@am__quote@ ++@AMDEP_TRUE@@am__include@ @am__quote@src/loongarch64/$(DEPDIR)/sysv.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@src/m32r/$(DEPDIR)/ffi.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@src/m32r/$(DEPDIR)/sysv.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@src/m68k/$(DEPDIR)/ffi.Plo@am__quote@ +@@ -1308,6 +1322,7 @@ clean-libtool: + -rm -rf src/frv/.libs src/frv/_libs + -rm -rf src/ia64/.libs src/ia64/_libs + -rm -rf src/kvx/.libs src/kvx/_libs ++ -rm -rf src/loongarch64/.libs src/loongarch64/_libs + -rm -rf src/m32r/.libs src/m32r/_libs + -rm -rf src/m68k/.libs src/m68k/_libs + -rm -rf src/m88k/.libs src/m88k/_libs +@@ -1658,6 +1673,8 @@ distclean-generic: + -rm -f src/ia64/$(am__dirstamp) + -rm -f src/kvx/$(DEPDIR)/$(am__dirstamp) + -rm -f src/kvx/$(am__dirstamp) ++ -rm -f src/loongarch64/$(DEPDIR)/$(am__dirstamp) ++ -rm -f src/loongarch64/$(am__dirstamp) + -rm -f src/m32r/$(DEPDIR)/$(am__dirstamp) + -rm -f src/m32r/$(am__dirstamp) + -rm -f src/m68k/$(DEPDIR)/$(am__dirstamp) +@@ -1712,7 +1729,7 @@ clean-am: clean-aminfo clean-generic clean-libtool clean-local \ + + distclean: distclean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) +- -rm -rf src/$(DEPDIR) src/aarch64/$(DEPDIR) src/alpha/$(DEPDIR) src/arc/$(DEPDIR) src/arm/$(DEPDIR) src/avr32/$(DEPDIR) src/bfin/$(DEPDIR) src/cris/$(DEPDIR) src/csky/$(DEPDIR) src/frv/$(DEPDIR) src/ia64/$(DEPDIR) src/kvx/$(DEPDIR) src/m32r/$(DEPDIR) src/m68k/$(DEPDIR) src/m88k/$(DEPDIR) src/metag/$(DEPDIR) src/microblaze/$(DEPDIR) src/mips/$(DEPDIR) src/moxie/$(DEPDIR) src/nios2/$(DEPDIR) src/or1k/$(DEPDIR) src/pa/$(DEPDIR) src/powerpc/$(DEPDIR) src/riscv/$(DEPDIR) src/s390/$(DEPDIR) src/sh/$(DEPDIR) src/sh64/$(DEPDIR) src/sparc/$(DEPDIR) src/tile/$(DEPDIR) src/vax/$(DEPDIR) src/x86/$(DEPDIR) src/xtensa/$(DEPDIR) ++ -rm -rf src/$(DEPDIR) src/aarch64/$(DEPDIR) src/alpha/$(DEPDIR) src/arc/$(DEPDIR) src/arm/$(DEPDIR) src/avr32/$(DEPDIR) src/bfin/$(DEPDIR) src/cris/$(DEPDIR) src/csky/$(DEPDIR) src/frv/$(DEPDIR) src/ia64/$(DEPDIR) src/kvx/$(DEPDIR) src/loongarch64/$(DEPDIR) src/m32r/$(DEPDIR) src/m68k/$(DEPDIR) src/m88k/$(DEPDIR) src/metag/$(DEPDIR) src/microblaze/$(DEPDIR) src/mips/$(DEPDIR) src/moxie/$(DEPDIR) src/nios2/$(DEPDIR) src/or1k/$(DEPDIR) src/pa/$(DEPDIR) src/powerpc/$(DEPDIR) src/riscv/$(DEPDIR) src/s390/$(DEPDIR) src/sh/$(DEPDIR) src/sh64/$(DEPDIR) src/sparc/$(DEPDIR) src/tile/$(DEPDIR) src/vax/$(DEPDIR) src/x86/$(DEPDIR) src/xtensa/$(DEPDIR) + -rm -f Makefile + distclean-am: clean-am distclean-compile distclean-generic \ + distclean-hdr distclean-libtool distclean-local distclean-tags +@@ -1851,7 +1868,7 @@ installcheck-am: + maintainer-clean: maintainer-clean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -rf $(top_srcdir)/autom4te.cache +- -rm -rf src/$(DEPDIR) src/aarch64/$(DEPDIR) src/alpha/$(DEPDIR) src/arc/$(DEPDIR) src/arm/$(DEPDIR) src/avr32/$(DEPDIR) src/bfin/$(DEPDIR) src/cris/$(DEPDIR) src/csky/$(DEPDIR) src/frv/$(DEPDIR) src/ia64/$(DEPDIR) src/kvx/$(DEPDIR) src/m32r/$(DEPDIR) src/m68k/$(DEPDIR) src/m88k/$(DEPDIR) src/metag/$(DEPDIR) src/microblaze/$(DEPDIR) src/mips/$(DEPDIR) src/moxie/$(DEPDIR) src/nios2/$(DEPDIR) src/or1k/$(DEPDIR) src/pa/$(DEPDIR) src/powerpc/$(DEPDIR) src/riscv/$(DEPDIR) src/s390/$(DEPDIR) src/sh/$(DEPDIR) src/sh64/$(DEPDIR) src/sparc/$(DEPDIR) src/tile/$(DEPDIR) src/vax/$(DEPDIR) src/x86/$(DEPDIR) src/xtensa/$(DEPDIR) ++ -rm -rf src/$(DEPDIR) src/aarch64/$(DEPDIR) src/alpha/$(DEPDIR) src/arc/$(DEPDIR) src/arm/$(DEPDIR) src/avr32/$(DEPDIR) src/bfin/$(DEPDIR) src/cris/$(DEPDIR) src/csky/$(DEPDIR) src/frv/$(DEPDIR) src/ia64/$(DEPDIR) src/kvx/$(DEPDIR) src/loongarch64/$(DEPDIR) src/m32r/$(DEPDIR) src/m68k/$(DEPDIR) src/m88k/$(DEPDIR) src/metag/$(DEPDIR) src/microblaze/$(DEPDIR) src/mips/$(DEPDIR) src/moxie/$(DEPDIR) src/nios2/$(DEPDIR) src/or1k/$(DEPDIR) src/pa/$(DEPDIR) src/powerpc/$(DEPDIR) src/riscv/$(DEPDIR) src/s390/$(DEPDIR) src/sh/$(DEPDIR) src/sh64/$(DEPDIR) src/sparc/$(DEPDIR) src/tile/$(DEPDIR) src/vax/$(DEPDIR) src/x86/$(DEPDIR) src/xtensa/$(DEPDIR) + -rm -f Makefile + maintainer-clean-am: distclean-am maintainer-clean-aminfo \ + maintainer-clean-generic maintainer-clean-local \ +diff --git a/libffi/configure.host b/libffi/configure.host +index 268267183..9d73f18ee 100644 +--- a/libffi/configure.host ++++ b/libffi/configure.host +@@ -140,6 +140,11 @@ case "${host}" in + SOURCES="ffi.c sysv.S" + ;; + ++ loongarch64-*-*) ++ TARGET=LOONGARCH64; TARGETDIR=loongarch64 ++ SOURCES="ffi.c sysv.S" ++ ;; ++ + m32r*-*-*) + TARGET=M32R; TARGETDIR=m32r + SOURCES="ffi.c sysv.S" +diff --git a/libffi/src/loongarch64/ffi.c b/libffi/src/loongarch64/ffi.c +new file mode 100644 +index 000000000..140be3bc3 +--- /dev/null ++++ b/libffi/src/loongarch64/ffi.c +@@ -0,0 +1,621 @@ ++/* ----------------------------------------------------------------------- ++ ffi.c - Copyright (c) 2022 Xu Chenghua <xuchenghua@loongson.cn> ++ 2022 Cheng Lulu <chenglulu@loongson.cn> ++ Based on RISC-V port ++ ++ LoongArch Foreign Function Interface ++ ++ Permission is hereby granted, free of charge, to any person obtaining ++ a copy of this software and associated documentation files (the ++ ``Software''), to deal in the Software without restriction, including ++ without limitation the rights to use, copy, modify, merge, publish, ++ distribute, sublicense, and/or sell copies of the Software, and to ++ permit persons to whom the Software is furnished to do so, subject to ++ the following conditions: ++ ++ The above copyright notice and this permission notice shall be included ++ in all copies or substantial portions of the Software. ++ ++ THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, ++ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ++ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ++ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ++ DEALINGS IN THE SOFTWARE. ++ ----------------------------------------------------------------------- */ ++ ++#include <ffi.h> ++#include <ffi_common.h> ++ ++#include <stdlib.h> ++#include <stdint.h> ++ ++#if defined(__loongarch_soft_float) ++# define ABI_FRLEN 0 ++#elif defined(__loongarch_single_float) ++# define ABI_FRLEN 32 ++# define ABI_FLOAT float ++#elif defined(__loongarch_double_float) ++# define ABI_FRLEN 64 ++# define ABI_FLOAT double ++#else ++#error unsupported LoongArch floating-point ABI ++#endif ++ ++#define NARGREG 8 ++#define STKALIGN 16 ++#define MAXCOPYARG (2 * sizeof (double)) ++ ++/* call_context registers ++ - 8 floating point parameter/result registers. ++ - 8 integer parameter/result registers. ++ - 2 registers used by the assembly code to in-place construct its own ++ stack frame ++ - frame register ++ - return register ++*/ ++typedef struct call_context ++{ ++ ABI_FLOAT fa8; ++ size_t a10; ++} call_context; ++ ++typedef struct call_builder ++{ ++ call_context *aregs; ++ int used_integer; ++ int used_float; ++ size_t *used_stack; ++ size_t *stack; ++ size_t next_struct_area; ++} call_builder; ++ ++/* Integer (not pointer) less than ABI GRLEN. */ ++/* FFI_TYPE_INT does not appear to be used. */ ++#if __SIZEOF_POINTER__ == 8 ++# define IS_INT(type) ((type) >= FFI_TYPE_UINT8 && (type) <= FFI_TYPE_SINT64) ++#else ++# define IS_INT(type) ((type) >= FFI_TYPE_UINT8 && (type) <= FFI_TYPE_SINT32) ++#endif ++ ++#if ABI_FRLEN ++typedef struct float_struct_info ++{ ++ char as_elements; ++ char type1; ++ char offset2; ++ char type2; ++} float_struct_info; ++ ++#if ABI_FRLEN >= 64 ++# define IS_FLOAT(type) ((type) >= FFI_TYPE_FLOAT && (type) <= FFI_TYPE_DOUBLE) ++#else ++# define IS_FLOAT(type) ((type) == FFI_TYPE_FLOAT) ++#endif ++ ++static ffi_type ** ++flatten_struct (ffi_type *in, ffi_type **out, ffi_type **out_end) ++{ ++ int i; ++ ++ if (out == out_end) ++ return out; ++ if (in->type != FFI_TYPE_STRUCT) ++ *(out++) = in; ++ else ++ for (i = 0; in->elementsi; i++) ++ out = flatten_struct (in->elementsi, out, out_end); ++ return out; ++} ++ ++/* Structs with at most two fields after flattening, one of which is of ++ floating point type, are passed in multiple registers if sufficient ++ registers are available. */ ++static float_struct_info ++struct_passed_as_elements (call_builder *cb, ffi_type *top) ++{ ++ float_struct_info ret = {0, 0, 0, 0}; ++ ffi_type *fields3; ++ int num_floats, num_ints; ++ int num_fields = flatten_struct (top, fields, fields + 3) - fields; ++ ++ if (num_fields == 1) ++ { ++ if (IS_FLOAT (fields0->type)) ++ { ++ ret.as_elements = 1; ++ ret.type1 = fields0->type; ++ } ++ } ++ else if (num_fields == 2) ++ { ++ num_floats = IS_FLOAT (fields0->type) + IS_FLOAT (fields1->type); ++ num_ints = IS_INT (fields0->type) + IS_INT (fields1->type); ++ if (num_floats == 0 || num_floats + num_ints != 2) ++ return ret; ++ if (cb->used_float + num_floats > NARGREG ++ || cb->used_integer + (2 - num_floats) > NARGREG) ++ return ret; ++ if (!IS_FLOAT (fields0->type) && !IS_FLOAT (fields1->type)) ++ return ret; ++ ++ ret.type1 = fields0->type; ++ ret.type2 = fields1->type; ++ ret.offset2 = FFI_ALIGN (fields0->size, fields1->alignment); ++ ret.as_elements = 1; ++ } ++ return ret; ++} ++#endif ++ ++/* Allocates a single register, float register, or GRLEN-sized stack slot to a ++ datum. */ ++static void ++marshal_atom (call_builder *cb, int type, void *data) ++{ ++ size_t value = 0; ++ switch (type) ++ { ++ case FFI_TYPE_UINT8: ++ value = *(uint8_t *) data; ++ break; ++ case FFI_TYPE_SINT8: ++ value = *(int8_t *) data; ++ break; ++ case FFI_TYPE_UINT16: ++ value = *(uint16_t *) data; ++ break; ++ case FFI_TYPE_SINT16: ++ value = *(int16_t *) data; ++ break; ++ /* 32-bit quantities are always sign-extended in the ABI. */ ++ case FFI_TYPE_UINT32: ++ value = *(int32_t *) data; ++ break; ++ case FFI_TYPE_SINT32: ++ value = *(int32_t *) data; ++ break; ++#if __SIZEOF_POINTER__ == 8 ++ case FFI_TYPE_UINT64: ++ value = *(uint64_t *) data; ++ break; ++ case FFI_TYPE_SINT64: ++ value = *(int64_t *) data; ++ break; ++#endif ++ case FFI_TYPE_POINTER: ++ value = *(size_t *) data; ++ break; ++ ++#if ABI_FRLEN >= 32 ++ case FFI_TYPE_FLOAT: ++ *(float *)(cb->aregs->fa + cb->used_float++) = *(float *) data; ++ return; ++#endif ++#if ABI_FRLEN >= 64 ++ case FFI_TYPE_DOUBLE: ++ (cb->aregs->facb->used_float++) = *(double *) data; ++ return; ++#endif ++ default: ++ FFI_ASSERT (0); ++ break; ++ } ++ ++ if (cb->used_integer == NARGREG) ++ *cb->used_stack++ = value; ++ else ++ cb->aregs->acb->used_integer++ = value; ++} ++ ++static void ++unmarshal_atom (call_builder *cb, int type, void *data) ++{ ++ size_t value; ++ switch (type) ++ { ++#if ABI_FRLEN >= 32 ++ case FFI_TYPE_FLOAT: ++ *(float *) data = *(float *)(cb->aregs->fa + cb->used_float++); ++ return; ++#endif ++#if ABI_FRLEN >= 64 ++ case FFI_TYPE_DOUBLE: ++ *(double *) data = cb->aregs->facb->used_float++; ++ return; ++#endif ++ } ++ ++ if (cb->used_integer == NARGREG) ++ value = *cb->used_stack++; ++ else ++ value = cb->aregs->acb->used_integer++; ++ ++ switch (type) ++ { ++ case FFI_TYPE_UINT8: ++ case FFI_TYPE_SINT8: ++ case FFI_TYPE_UINT16: ++ case FFI_TYPE_SINT16: ++ case FFI_TYPE_UINT32: ++ case FFI_TYPE_SINT32: ++#if __SIZEOF_POINTER__ == 8 ++ case FFI_TYPE_UINT64: ++ case FFI_TYPE_SINT64: ++#endif ++ case FFI_TYPE_POINTER: ++ *(ffi_arg *)data = value; ++ break; ++ default: ++ FFI_ASSERT (0); ++ break; ++ } ++} ++ ++/* Allocate and copy a structure that is passed by value on the stack and ++ return a pointer to it. */ ++static void * ++allocate_and_copy_struct_to_stack (call_builder *cb, void *data, ++ ffi_type *type) ++{ ++ size_t dest = cb->next_struct_area - type->size; ++ ++ dest = FFI_ALIGN_DOWN (dest, type->alignment); ++ cb->next_struct_area = dest; ++ ++ return memcpy ((char *)cb->stack + dest, data, type->size); ++} ++ ++/* Adds an argument to a call, or a not by reference return value. */ ++static void ++marshal (call_builder *cb, ffi_type *type, int var, void *data) ++{ ++ size_t realign2; ++ ++#if ABI_FRLEN ++ if (!var && type->type == FFI_TYPE_STRUCT) ++ { ++ float_struct_info fsi = struct_passed_as_elements (cb, type); ++ if (fsi.as_elements) ++ { ++ marshal_atom (cb, fsi.type1, data); ++ if (fsi.offset2) ++ marshal_atom (cb, fsi.type2, ((char *) data) + fsi.offset2); ++ return; ++ } ++ } ++ ++ if (!var && cb->used_float < NARGREG ++ && IS_FLOAT (type->type)) ++ { ++ marshal_atom (cb, type->type, data); ++ return; ++ } ++ ++ double promoted; ++ if (var && type->type == FFI_TYPE_FLOAT) ++ { ++ /* C standard requires promoting float -> double for variable arg. */ ++ promoted = *(float *) data; ++ type = &ffi_type_double; ++ data = &promoted; ++ } ++#endif ++ ++ if (type->size > 2 * __SIZEOF_POINTER__) ++ /* Pass by reference. */ ++ { ++ allocate_and_copy_struct_to_stack (cb, data, type); ++ data = (char *)cb->stack + cb->next_struct_area; ++ marshal_atom (cb, FFI_TYPE_POINTER, &data); ++ } ++ else if (IS_INT (type->type) || type->type == FFI_TYPE_POINTER) ++ marshal_atom (cb, type->type, data); ++ else ++ { ++ /* Overlong integers, soft-float floats, and structs without special ++ float handling are treated identically from this point on. */ ++ ++ /* Variadics are aligned even in registers. */ ++ if (type->alignment > __SIZEOF_POINTER__) ++ { ++ if (var) ++ cb->used_integer = FFI_ALIGN (cb->used_integer, 2); ++ cb->used_stack ++ = (size_t *) FFI_ALIGN (cb->used_stack, 2 * __SIZEOF_POINTER__); ++ } ++ ++ memcpy (realign, data, type->size); ++ if (type->size > 0) ++ marshal_atom (cb, FFI_TYPE_POINTER, realign); ++ if (type->size > __SIZEOF_POINTER__) ++ marshal_atom (cb, FFI_TYPE_POINTER, realign + 1); ++ } ++} ++ ++/* For arguments passed by reference returns the pointer, otherwise the arg ++ is copied (up to MAXCOPYARG bytes). */ ++static void * ++unmarshal (call_builder *cb, ffi_type *type, int var, void *data) ++{ ++ size_t realign2; ++ void *pointer; ++ ++#if ABI_FRLEN ++ if (!var && type->type == FFI_TYPE_STRUCT) ++ { ++ float_struct_info fsi = struct_passed_as_elements (cb, type); ++ if (fsi.as_elements) ++ { ++ unmarshal_atom (cb, fsi.type1, data); ++ if (fsi.offset2) ++ unmarshal_atom (cb, fsi.type2, ((char *) data) + fsi.offset2); ++ return data; ++ } ++ } ++ ++ if (!var && cb->used_float < NARGREG ++ && IS_FLOAT (type->type)) ++ { ++ unmarshal_atom (cb, type->type, data); ++ return data; ++ } ++ ++ if (var && type->type == FFI_TYPE_FLOAT) ++ { ++ int m = cb->used_integer; ++ void *promoted ++ = m < NARGREG ? cb->aregs->a + m : cb->used_stack + m - NARGREG + 1; ++ *(float *) promoted = *(double *) promoted; ++ } ++#endif ++ ++ if (type->size > 2 * __SIZEOF_POINTER__) ++ { ++ /* Pass by reference. */ ++ unmarshal_atom (cb, FFI_TYPE_POINTER, (char *) &pointer); ++ return pointer; ++ } ++ else if (IS_INT (type->type) || type->type == FFI_TYPE_POINTER) ++ { ++ unmarshal_atom (cb, type->type, data); ++ return data; ++ } ++ else ++ { ++ /* Overlong integers, soft-float floats, and structs without special ++ float handling are treated identically from this point on. */ ++ ++ /* Variadics are aligned even in registers. */ ++ if (type->alignment > __SIZEOF_POINTER__) ++ { ++ if (var) ++ cb->used_integer = FFI_ALIGN (cb->used_integer, 2); ++ cb->used_stack ++ = (size_t *) FFI_ALIGN (cb->used_stack, 2 * __SIZEOF_POINTER__); ++ } ++ ++ if (type->size > 0) ++ unmarshal_atom (cb, FFI_TYPE_POINTER, realign); ++ if (type->size > __SIZEOF_POINTER__) ++ unmarshal_atom (cb, FFI_TYPE_POINTER, realign + 1); ++ memcpy (data, realign, type->size); ++ return data; ++ } ++} ++ ++static int ++passed_by_ref (call_builder *cb, ffi_type *type, int var) ++{ ++#if ABI_FRLEN ++ if (!var && type->type == FFI_TYPE_STRUCT) ++ { ++ float_struct_info fsi = struct_passed_as_elements (cb, type); ++ if (fsi.as_elements) ++ return 0; ++ } ++#endif ++ ++ return type->size > 2 * __SIZEOF_POINTER__; ++} ++ ++/* Perform machine dependent cif processing. */ ++ffi_status ++ffi_prep_cif_machdep (ffi_cif *cif) ++{ ++ cif->loongarch_nfixedargs = cif->nargs; ++ return FFI_OK; ++} ++ ++/* Perform machine dependent cif processing when we have a variadic ++ function. */ ++ffi_status ++ffi_prep_cif_machdep_var (ffi_cif *cif, unsigned int nfixedargs, ++ unsigned int ntotalargs) ++{ ++ cif->loongarch_nfixedargs = nfixedargs; ++ return FFI_OK; ++} ++ ++/* Low level routine for calling functions. */ ++extern void ffi_call_asm (void *stack, struct call_context *regs, ++ void (*fn) (void), void *closure) FFI_HIDDEN; ++ ++static void ++ffi_call_int (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue, ++ void *closure) ++{ ++ /* This is a conservative estimate, assuming a complex return value and ++ that all remaining arguments are long long / __int128 */ ++ size_t arg_bytes = cif->bytes; ++ size_t rval_bytes = 0; ++ if (rvalue == NULL && cif->rtype->size > 2 * __SIZEOF_POINTER__) ++ rval_bytes = FFI_ALIGN (cif->rtype->size, STKALIGN); ++ size_t alloc_size = arg_bytes + rval_bytes + sizeof (call_context); ++ ++ /* The assembly code will deallocate all stack data at lower addresses ++ than the argument region, so we need to allocate the frame and the ++ return value after the arguments in a single allocation. */ ++ size_t alloc_base; ++ /* Argument region must be 16-byte aligned in LP64 ABIs. */ ++ if (_Alignof(max_align_t) >= STKALIGN) ++ /* Since sizeof long double is normally 16, the compiler will ++ guarantee alloca alignment to at least that much. */ ++ alloc_base = (size_t) alloca (alloc_size); ++ else ++ alloc_base = FFI_ALIGN (alloca (alloc_size + STKALIGN - 1), STKALIGN); ++ ++ if (rval_bytes) ++ rvalue = (void *) (alloc_base + arg_bytes); ++ ++ call_builder cb; ++ cb.used_float = cb.used_integer = 0; ++ cb.aregs = (call_context *) (alloc_base + arg_bytes + rval_bytes); ++ cb.used_stack = (void *) alloc_base; ++ cb.stack = (void *) alloc_base; ++ cb.next_struct_area = arg_bytes; ++ ++ int return_by_ref = passed_by_ref (&cb, cif->rtype, 0); ++ if (return_by_ref) ++ cb.aregs->acb.used_integer++ = (size_t)rvalue; ++ ++ int i; ++ for (i = 0; i < cif->nargs; i++) ++ marshal (&cb, cif->arg_typesi, i >= cif->loongarch_nfixedargs, ++ avaluei); ++ ++ ffi_call_asm ((void *) alloc_base, cb.aregs, fn, closure); ++ ++ cb.used_float = cb.used_integer = 0; ++ if (!return_by_ref && rvalue) ++ unmarshal (&cb, cif->rtype, 0, rvalue); ++} ++ ++void ++ffi_call (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue) ++{ ++ ffi_call_int (cif, fn, rvalue, avalue, NULL); ++} ++ ++void ++ffi_call_go (ffi_cif *cif, void (*fn) (void), void *rvalue, void **avalue, ++ void *closure) ++{ ++ ffi_call_int (cif, fn, rvalue, avalue, closure); ++} ++ ++extern void ffi_closure_asm (void) FFI_HIDDEN; ++ ++ffi_status ++ffi_prep_closure_loc (ffi_closure *closure, ffi_cif *cif, ++ void (*fun) (ffi_cif *, void *, void **, void *), ++ void *user_data, void *codeloc) ++{ ++ uint32_t *tramp = (uint32_t *) &closure->tramp0; ++ uint64_t fn = (uint64_t) (uintptr_t) ffi_closure_asm; ++ ++ if (cif->abi <= FFI_FIRST_ABI || cif->abi >= FFI_LAST_ABI) ++ return FFI_BAD_ABI; ++ ++#if defined(FFI_EXEC_STATIC_TRAMP) ++ if (ffi_tramp_is_present(closure)) ++ { ++ ffi_tramp_set_parms (closure->ftramp, ffi_closure_asm, closure); ++ goto out; ++ } ++#endif ++ ++ /* Fill the dynamic trampoline. We will call ffi_closure_inner with codeloc, ++ not closure, but as long as the memory is readable it should work. */ ++ tramp0 = 0x1800000c; /* pcaddi $t0, 0 (i.e. $t0 <- tramp) */ ++ tramp1 = 0x28c0418d; /* ld.d $t1, $t0, 16 */ ++ tramp2 = 0x4c0001a0; /* jirl $zero, $t1, 0 */ ++ tramp3 = 0x03400000; /* nop */ ++ tramp4 = fn; ++ tramp5 = fn >> 32; ++ ++ __builtin___clear_cache (codeloc, codeloc + FFI_TRAMPOLINE_SIZE); ++ ++#if defined(FFI_EXEC_STATIC_TRAMP) ++out: ++#endif ++ closure->cif = cif; ++ closure->fun = fun; ++ closure->user_data = user_data; ++ ++ return FFI_OK; ++} ++ ++extern void ffi_go_closure_asm (void) FFI_HIDDEN; ++ ++ffi_status ++ffi_prep_go_closure (ffi_go_closure *closure, ffi_cif *cif, ++ void (*fun) (ffi_cif *, void *, void **, void *)) ++{ ++ if (cif->abi <= FFI_FIRST_ABI || cif->abi >= FFI_LAST_ABI) ++ return FFI_BAD_ABI; ++ ++ closure->tramp = (void *) ffi_go_closure_asm; ++ closure->cif = cif; ++ closure->fun = fun; ++ return FFI_OK; ++} ++ ++/* Called by the assembly code with aregs pointing to saved argument registers ++ and stack pointing to the stacked arguments. Return values passed in ++ registers will be reloaded from aregs. */ ++void FFI_HIDDEN ++ffi_closure_inner (ffi_cif *cif, ++ void (*fun) (ffi_cif *, void *, void **, void *), ++ void *user_data, size_t *stack, call_context *aregs) ++{ ++ void **avalue = alloca (cif->nargs * sizeof (void *)); ++ /* Storage for arguments which will be copied by unmarshal(). We could ++ theoretically avoid the copies in many cases and use at most 128 bytes ++ of memory, but allocating disjoint storage for each argument is ++ simpler. */ ++ char *astorage = alloca (cif->nargs * MAXCOPYARG); ++ void *rvalue; ++ call_builder cb; ++ int return_by_ref; ++ int i; ++ ++ cb.aregs = aregs; ++ cb.used_integer = cb.used_float = 0; ++ cb.used_stack = stack; ++ ++ return_by_ref = passed_by_ref (&cb, cif->rtype, 0); ++ if (return_by_ref) ++ unmarshal (&cb, &ffi_type_pointer, 0, &rvalue); ++ else ++ rvalue = alloca (cif->rtype->size); ++ ++ for (i = 0; i < cif->nargs; i++) ++ avaluei ++ = unmarshal (&cb, cif->arg_typesi, i >= cif->loongarch_nfixedargs, ++ astorage + i * MAXCOPYARG); ++ ++ fun (cif, rvalue, avalue, user_data); ++ ++ if (!return_by_ref && cif->rtype->type != FFI_TYPE_VOID) ++ { ++ cb.used_integer = cb.used_float = 0; ++ marshal (&cb, cif->rtype, 0, rvalue); ++ } ++} ++ ++#if defined(FFI_EXEC_STATIC_TRAMP) ++void * ++ffi_tramp_arch (size_t *tramp_size, size_t *map_size) ++{ ++ extern void *trampoline_code_table; ++ ++ *tramp_size = 16; ++ /* A mapping size of 64K is chosen to cover the page sizes of 4K, 16K, and ++ 64K. */ ++ *map_size = 1 << 16; ++ return &trampoline_code_table; ++} ++#endif +diff --git a/libffi/src/loongarch64/ffitarget.h b/libffi/src/loongarch64/ffitarget.h +new file mode 100644 +index 000000000..5a4698af3 +--- /dev/null ++++ b/libffi/src/loongarch64/ffitarget.h +@@ -0,0 +1,82 @@ ++/* -----------------------------------------------------------------*-C-*- ++ ffitarget.h - Copyright (c) 2022 Xu Chenghua <xuchenghua@loongson.cn> ++ 2022 Cheng Lulu <chenglulu@loongson.cn> ++ ++ Target configuration macros for LoongArch. ++ ++ Permission is hereby granted, free of charge, to any person obtaining ++ a copy of this software and associated documentation files (the ++ ``Software''), to deal in the Software without restriction, including ++ without limitation the rights to use, copy, modify, merge, publish, ++ distribute, sublicense, and/or sell copies of the Software, and to ++ permit persons to whom the Software is furnished to do so, subject to ++ the following conditions: ++ ++ The above copyright notice and this permission notice shall be included ++ in all copies or substantial portions of the Software. ++ ++ THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, ++ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ++ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ++ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ++ DEALINGS IN THE SOFTWARE. ++ ++ ----------------------------------------------------------------------- */ ++ ++#ifndef LIBFFI_TARGET_H ++#define LIBFFI_TARGET_H ++ ++#ifndef LIBFFI_H ++#error \ ++ "Please do not include ffitarget.h directly into your source. Use ffi.h instead." ++#endif ++ ++#ifndef __loongarch__ ++#error \ ++ "libffi was configured for a LoongArch target but this does not appear to be a LoongArch compiler." ++#endif ++ ++#ifndef LIBFFI_ASM ++ ++typedef unsigned long ffi_arg; ++typedef signed long ffi_sarg; ++ ++typedef enum ffi_abi ++{ ++ FFI_FIRST_ABI = 0, ++ FFI_LP64S, ++ FFI_LP64F, ++ FFI_LP64D, ++ FFI_LAST_ABI, ++ ++#if defined(__loongarch64) ++#if defined(__loongarch_soft_float) ++ FFI_DEFAULT_ABI = FFI_LP64S ++#elif defined(__loongarch_single_float) ++ FFI_DEFAULT_ABI = FFI_LP64F ++#elif defined(__loongarch_double_float) ++ FFI_DEFAULT_ABI = FFI_LP64D ++#else ++#error unsupported LoongArch floating-point ABI ++#endif ++#else ++#error unsupported LoongArch base architecture ++#endif ++} ffi_abi; ++ ++#endif /* LIBFFI_ASM */ ++ ++/* ---- Definitions for closures ----------------------------------------- */ ++ ++#define FFI_CLOSURES 1 ++#define FFI_GO_CLOSURES 1 ++#define FFI_TRAMPOLINE_SIZE 24 ++#define FFI_NATIVE_RAW_API 0 ++#define FFI_EXTRA_CIF_FIELDS \ ++ unsigned loongarch_nfixedargs; \ ++ unsigned loongarch_unused; ++#define FFI_TARGET_SPECIFIC_VARIADIC ++#endif +diff --git a/libffi/src/loongarch64/sysv.S b/libffi/src/loongarch64/sysv.S +new file mode 100644 +index 000000000..aa7bde2c1 +--- /dev/null ++++ b/libffi/src/loongarch64/sysv.S +@@ -0,0 +1,327 @@ ++/* ----------------------------------------------------------------------- ++ sysv.S - Copyright (c) 2022 Xu Chenghua <xuchenghua@loongson.cn> ++ 2022 Cheng Lulu <chenglulu@loongson.cn> ++ ++ LoongArch Foreign Function Interface ++ ++ Permission is hereby granted, free of charge, to any person obtaining ++ a copy of this software and associated documentation files (the ++ ``Software''), to deal in the Software without restriction, including ++ without limitation the rights to use, copy, modify, merge, publish, ++ distribute, sublicense, and/or sell copies of the Software, and to ++ permit persons to whom the Software is furnished to do so, subject to ++ the following conditions: ++ ++ The above copyright notice and this permission notice shall be included ++ in all copies or substantial portions of the Software. ++ ++ THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, ++ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ++ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ++ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ++ DEALINGS IN THE SOFTWARE. ++ ----------------------------------------------------------------------- */ ++ ++#define LIBFFI_ASM ++#include <fficonfig.h> ++#include <ffi.h> ++ ++/* Define aliases so that we can handle all ABIs uniformly. */ ++ ++#if __SIZEOF_POINTER__ == 8 ++# define PTRS 8 ++# define LARG ld.d ++# define SARG st.d ++#else ++# define PTRS 4 ++# define LARG ld.w ++# define SARG st.w ++#endif ++ ++#if defined(__loongarch_single_float) ++# define FLTS 4 ++# define FLD fld.w ++# define FST fst.w ++#elif defined(__loongarch_double_float) ++# define FLTS 8 ++# define FLARG fld.d ++# define FSARG fst.d ++#elif defined(__loongarch_soft_float) ++# define FLTS 0 ++#else ++#error unsupported LoongArch floating-point ABI ++#endif ++ ++ .text ++ .globl ffi_call_asm ++ .type ffi_call_asm, @function ++ .hidden ffi_call_asm ++/* struct call_context ++ { ++ ABI_FLOAT fa8; ++ size_t a10; ++ } ++ ++ - 8 floating point parameter/result registers (fa0 - fa7) ++ - 8 integer parameter/result registers (a0 - a7) ++ - 2 registers used by the assembly code to in-place construct its own stack ++ frame. ++ - frame pointer (a8) ++ - return address (a9) ++ ++ void ffi_call_asm (size_t *stackargs, struct call_context *regargs, ++ void (*fn)(void), void *closure); */ ++ ++#define FRAME_LEN (8 * FLTS + 10 * PTRS) ++ ++ffi_call_asm: ++ .cfi_startproc ++ ++ /* We are NOT going to set up an ordinary stack frame. In order to pass ++ the stacked args to the called function, we adjust our stack pointer ++ to a0, which is in the _caller's_ alloca area. We establish our own ++ stack frame at the end of the call_context. ++ ++ Anything below the arguments will be freed at this point, although ++ we preserve the call_context so that it can be read back in the ++ caller. */ ++ ++ .cfi_def_cfa 5, FRAME_LEN # Interim CFA based on a1. ++ SARG $fp, $a1, FRAME_LEN - 2*PTRS ++ .cfi_offset 22, -2*PTRS ++ SARG $ra, $a1, FRAME_LEN - 1*PTRS ++ .cfi_offset 1, -1*PTRS ++ ++ addi.d $fp, $a1, FRAME_LEN ++ move $sp, $a0 ++ .cfi_def_cfa 22, 0 # Our frame is fully set up. ++ ++ # Load arguments. ++ move $t1, $a2 ++ move $t2, $a3 ++ ++#if FLTS ++ FLARG $fa0, $fp, -FRAME_LEN+0*FLTS ++ FLARG $fa1, $fp, -FRAME_LEN+1*FLTS ++ FLARG $fa2, $fp, -FRAME_LEN+2*FLTS ++ FLARG $fa3, $fp, -FRAME_LEN+3*FLTS ++ FLARG $fa4, $fp, -FRAME_LEN+4*FLTS ++ FLARG $fa5, $fp, -FRAME_LEN+5*FLTS ++ FLARG $fa6, $fp, -FRAME_LEN+6*FLTS ++ FLARG $fa7, $fp, -FRAME_LEN+7*FLTS ++#endif ++ ++ LARG $a0, $fp, -FRAME_LEN+8*FLTS+0*PTRS ++ LARG $a1, $fp, -FRAME_LEN+8*FLTS+1*PTRS ++ LARG $a2, $fp, -FRAME_LEN+8*FLTS+2*PTRS ++ LARG $a3, $fp, -FRAME_LEN+8*FLTS+3*PTRS ++ LARG $a4, $fp, -FRAME_LEN+8*FLTS+4*PTRS ++ LARG $a5, $fp, -FRAME_LEN+8*FLTS+5*PTRS ++ LARG $a6, $fp, -FRAME_LEN+8*FLTS+6*PTRS ++ LARG $a7, $fp, -FRAME_LEN+8*FLTS+7*PTRS ++ ++ /* Call */ ++ jirl $ra, $t1, 0 ++ ++#if FLTS ++ /* Save return values - only a0/a1 (fa0/fa1) are used. */ ++ FSARG $fa0, $fp, -FRAME_LEN+0*FLTS ++ FSARG $fa1, $fp, -FRAME_LEN+1*FLTS ++#endif ++ ++ SARG $a0, $fp, -FRAME_LEN+8*FLTS+0*PTRS ++ SARG $a1, $fp, -FRAME_LEN+8*FLTS+1*PTRS ++ ++ /* Restore and return. */ ++ addi.d $sp, $fp, -FRAME_LEN ++ .cfi_def_cfa 3, FRAME_LEN ++ LARG $ra, $fp, -1*PTRS ++ .cfi_restore 1 ++ LARG $fp, $fp, -2*PTRS ++ .cfi_restore 22 ++ jr $ra ++ .cfi_endproc ++ .size ffi_call_asm, .-ffi_call_asm ++ ++ ++/* ffi_closure_asm. Expects address of the passed-in ffi_closure in t0. ++ void ffi_closure_inner (ffi_cif *cif, ++ void (*fun)(ffi_cif *, void *, void **, void *), ++ void *user_data, ++ size_t *stackargs, struct call_context *regargs) */ ++ ++ .globl ffi_closure_asm ++ .hidden ffi_closure_asm ++ .type ffi_closure_asm, @function ++ ++ffi_closure_asm: ++ .cfi_startproc ++ addi.d $sp, $sp, -FRAME_LEN ++ .cfi_def_cfa_offset FRAME_LEN ++ ++ /* Make a frame. */ ++ SARG $fp, $sp, FRAME_LEN - 2*PTRS ++ .cfi_offset 22, -2*PTRS ++ SARG $ra, $sp, FRAME_LEN - 1*PTRS ++ .cfi_offset 1, -1*PTRS ++ addi.d $fp, $sp, FRAME_LEN ++ ++ /* Save arguments. */ ++#if FLTS ++ FSARG $fa0, $sp, 0*FLTS ++ FSARG $fa1, $sp, 1*FLTS ++ FSARG $fa2, $sp, 2*FLTS ++ FSARG $fa3, $sp, 3*FLTS ++ FSARG $fa4, $sp, 4*FLTS ++ FSARG $fa5, $sp, 5*FLTS ++ FSARG $fa6, $sp, 6*FLTS ++ FSARG $fa7, $sp, 7*FLTS ++#endif ++ ++ SARG $a0, $sp, 8*FLTS+0*PTRS ++ SARG $a1, $sp, 8*FLTS+1*PTRS ++ SARG $a2, $sp, 8*FLTS+2*PTRS ++ SARG $a3, $sp, 8*FLTS+3*PTRS ++ SARG $a4, $sp, 8*FLTS+4*PTRS ++ SARG $a5, $sp, 8*FLTS+5*PTRS ++ SARG $a6, $sp, 8*FLTS+6*PTRS ++ SARG $a7, $sp, 8*FLTS+7*PTRS ++ ++ /* Enter C */ ++ LARG $a0, $t0, FFI_TRAMPOLINE_SIZE+0*PTRS ++ LARG $a1, $t0, FFI_TRAMPOLINE_SIZE+1*PTRS ++ LARG $a2, $t0, FFI_TRAMPOLINE_SIZE+2*PTRS ++ addi.d $a3, $sp, FRAME_LEN ++ move $a4, $sp ++ ++ bl ffi_closure_inner ++ ++ /* Return values. */ ++#if FLTS ++ FLARG $fa0, $sp, 0*FLTS ++ FLARG $fa1, $sp, 1*FLTS ++#endif ++ ++ LARG $a0, $sp, 8*FLTS+0*PTRS ++ LARG $a1, $sp, 8*FLTS+1*PTRS ++ ++ /* Restore and return. */ ++ LARG $ra, $sp, FRAME_LEN-1*PTRS ++ .cfi_restore 1 ++ LARG $fp, $sp, FRAME_LEN-2*PTRS ++ .cfi_restore 22 ++ addi.d $sp, $sp, FRAME_LEN ++ .cfi_def_cfa_offset 0 ++ jr $ra ++ .cfi_endproc ++ .size ffi_closure_asm, .-ffi_closure_asm ++ ++/* Static trampoline code table, in which each element is a trampoline. ++ ++ The trampoline clobbers t0 and t1, but we don't save them on the stack ++ because our psABI explicitly says they are scratch registers, at least for ++ ELF. Our dynamic trampoline is already clobbering them anyway. ++ ++ The trampoline has two parameters - target code to jump to and data for ++ the target code. The trampoline extracts the parameters from its parameter ++ block (see tramp_table_map()). The trampoline saves the data address in ++ t0 and jumps to the target code. As ffi_closure_asm() already expects the ++ data address to be in t0, we don't need a "ffi_closure_asm_alt". */ ++ ++#if defined(FFI_EXEC_STATIC_TRAMP) ++ .align 16 ++ .globl trampoline_code_table ++ .hidden trampoline_code_table ++ .type trampoline_code_table, @function ++ ++trampoline_code_table: ++ ++ .rept 65536 / 16 ++ pcaddu12i $t1, 16 # 65536 >> 12 ++ ld.d $t0, $t1, 0 ++ ld.d $t1, $t1, 8 ++ jirl $zero, $t1, 0 ++ .endr ++ .size trampoline_code_table, .-trampoline_code_table ++ ++ .align 2 ++#endif ++ ++/* ffi_go_closure_asm. Expects address of the passed-in ffi_go_closure in t2. ++ void ffi_closure_inner (ffi_cif *cif, ++ void (*fun)(ffi_cif *, void *, void **, void *), ++ void *user_data, ++ size_t *stackargs, struct call_context *regargs) */ ++ ++ .globl ffi_go_closure_asm ++ .hidden ffi_go_closure_asm ++ .type ffi_go_closure_asm, @function ++ ++ffi_go_closure_asm: ++ .cfi_startproc ++ addi.d $sp, $sp, -FRAME_LEN ++ .cfi_def_cfa_offset FRAME_LEN ++ ++ /* Make a frame. */ ++ SARG $fp, $sp, FRAME_LEN - 2*PTRS ++ .cfi_offset 22, -2*PTRS ++ SARG $ra, $sp, FRAME_LEN - 1*PTRS ++ .cfi_offset 1, -1*PTRS ++ addi.d $fp, $sp, FRAME_LEN ++ ++ /* Save arguments. */ ++#if FLTS ++ FSARG $fa0, $sp, 0*FLTS ++ FSARG $fa1, $sp, 1*FLTS ++ FSARG $fa2, $sp, 2*FLTS ++ FSARG $fa3, $sp, 3*FLTS ++ FSARG $fa4, $sp, 4*FLTS ++ FSARG $fa5, $sp, 5*FLTS ++ FSARG $fa6, $sp, 6*FLTS ++ FSARG $fa7, $sp, 7*FLTS ++#endif ++ ++ SARG $a0, $sp, 8*FLTS+0*PTRS ++ SARG $a1, $sp, 8*FLTS+1*PTRS ++ SARG $a2, $sp, 8*FLTS+2*PTRS ++ SARG $a3, $sp, 8*FLTS+3*PTRS ++ SARG $a4, $sp, 8*FLTS+4*PTRS ++ SARG $a5, $sp, 8*FLTS+5*PTRS ++ SARG $a6, $sp, 8*FLTS+6*PTRS ++ SARG $a7, $sp, 8*FLTS+7*PTRS ++ ++ /* Enter C */ ++ LARG $a0, $t2, 1*PTRS ++ LARG $a1, $t2, 2*PTRS ++ move $a2, $t2 ++ addi.d $a3, $sp, FRAME_LEN ++ move $a4, $sp ++ ++ bl ffi_closure_inner ++ ++ /* Return values. */ ++#if FLTS ++ FLARG $fa0, $sp, 0*FLTS ++ FLARG $fa1, $sp, 1*FLTS ++#endif ++ ++ LARG $a0, $sp, 8*FLTS+0*PTRS ++ LARG $a1, $sp, 8*FLTS+1*PTRS ++ ++ /* Restore and return. */ ++ LARG $ra, $sp, FRAME_LEN-1*PTRS ++ .cfi_restore 1 ++ LARG $fp, $sp, FRAME_LEN-2*PTRS ++ .cfi_restore 22 ++ addi.d $sp, $sp, FRAME_LEN ++ .cfi_def_cfa_offset 0 ++ jr $ra ++ .cfi_endproc ++ .size ffi_go_closure_asm, .-ffi_go_closure_asm ++ ++#if defined __ELF__ && defined __linux__ ++ .section .note.GNU-stack,"",%progbits ++#endif +-- +2.33.0 +
View file
_service:tar_scm:libjccjit-do-not-link-objects-contained-same-element.patch
Added
@@ -0,0 +1,44 @@ +From 579464905cd757f219344d657f8929ecfa33c0e2 Mon Sep 17 00:00:00 2001 +From: Peng Fan <fanpeng@loongson.cn> +Date: Fri, 28 Jul 2023 09:58:05 +0800 +Subject: PATCH 2/3 libjccjit: do not link objects contained same element + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/jit/Make-lang.in | 9 +++++++-- + 1 file changed, 7 insertions(+), 2 deletions(-) + +diff --git a/gcc/jit/Make-lang.in b/gcc/jit/Make-lang.in +index 6e10abfd0..7f53304d9 100644 +--- a/gcc/jit/Make-lang.in ++++ b/gcc/jit/Make-lang.in +@@ -157,18 +157,23 @@ LIBGCCJIT_EXTRA_OPTS = $(LIBGCCJIT_VERSION_SCRIPT_OPTION) \ + endif + endif + ++# Only link objects from $(EXTRA_GCC_OBJS) that's not already ++# included in libbackend.a ($(EXTRA_OBJS)). ++EXTRA_GCC_OBJS_EXCLUSIVE = $(foreach _obj1, $(EXTRA_GCC_OBJS), \ ++ $(if $(filter $(_obj1), $(EXTRA_OBJS)),, $(_obj1))) ++ + # We avoid using $(BACKEND) from Makefile.in in order to avoid pulling + # in main.o + $(LIBGCCJIT_FILENAME): $(jit_OBJS) \ + libbackend.a libcommon-target.a libcommon.a \ + $(CPPLIB) $(LIBDECNUMBER) \ + $(LIBDEPS) $(srcdir)/jit/libgccjit.map \ +- $(EXTRA_GCC_OBJS) $(jit.prev) ++ $(EXTRA_GCC_OBJS_EXCLUSIVE) $(jit.prev) + @$(call LINK_PROGRESS,$(INDEX.jit),start) + +$(LLINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) -o $@ -shared \ + $(jit_OBJS) libbackend.a libcommon-target.a libcommon.a \ + $(CPPLIB) $(LIBDECNUMBER) $(EXTRA_GCC_LIBS) $(LIBS) $(BACKENDLIBS) \ +- $(EXTRA_GCC_OBJS) \ ++ $(EXTRA_GCC_OBJS_EXCLUSIVE) \ + $(LIBGCCJIT_EXTRA_OPTS) + @$(call LINK_PROGRESS,$(INDEX.jit),end) + +-- +2.33.0 +
View file
_service:tar_scm:libsanitizer-add-LoongArch-support.patch
Added
@@ -0,0 +1,1372 @@ +From e9ff5810cfbc76b24adefcfd024d69c19789119c Mon Sep 17 00:00:00 2001 +From: ticat_fp <fanpeng@loongson.cn> +Date: Wed, 28 Feb 2024 15:13:42 +0800 +Subject: PATCH 124/124 libsanitizer: add LoongArch support + +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + libsanitizer/asan/asan_interceptors.h | 2 +- + libsanitizer/asan/asan_interceptors_vfork.S | 1 + + libsanitizer/asan/asan_mapping.h | 3 + + libsanitizer/configure.tgt | 7 + + libsanitizer/lsan/lsan_allocator.h | 3 +- + libsanitizer/lsan/lsan_common.cpp | 4 + + .../sanitizer_common/sanitizer_common.h | 3 + + ...ommon_interceptors_vfork_loongarch64.inc.S | 57 +++++ + .../sanitizer_common_syscalls.inc | 4 +- + .../sanitizer_common/sanitizer_linux.cpp | 111 +++++++++- + .../sanitizer_common/sanitizer_linux.h | 2 +- + .../sanitizer_linux_libcdep.cpp | 19 +- + .../sanitizer_common/sanitizer_platform.h | 10 +- + .../sanitizer_platform_limits_linux.cpp | 3 +- + .../sanitizer_platform_limits_posix.cpp | 13 +- + .../sanitizer_platform_limits_posix.h | 7 +- + .../sanitizer_common/sanitizer_stacktrace.cpp | 4 +- + .../sanitizer_stoptheworld_linux_libcdep.cpp | 11 +- + .../sanitizer_symbolizer_libcdep.cpp | 2 + + .../sanitizer_syscall_linux_loongarch64.inc | 171 +++++++++++++++ + ...ommon_interceptors_vfork_loongarch64.inc.S | 57 +++++ + libsanitizer/tsan/Makefile.am | 2 +- + libsanitizer/tsan/Makefile.in | 3 +- + libsanitizer/tsan/tsan_interceptors_posix.cpp | 2 + + libsanitizer/tsan/tsan_platform.h | 55 +++++ + libsanitizer/tsan/tsan_platform_linux.cpp | 21 +- + libsanitizer/tsan/tsan_rtl.h | 3 +- + libsanitizer/tsan/tsan_rtl_loongarch64.S | 196 ++++++++++++++++++ + 28 files changed, 749 insertions(+), 27 deletions(-) + create mode 100644 libsanitizer/sanitizer_common/sanitizer_common_interceptors_vfork_loongarch64.inc.S + create mode 100644 libsanitizer/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc + create mode 100644 libsanitizer/sanitizer_common_interceptors_vfork_loongarch64.inc.S + create mode 100644 libsanitizer/tsan/tsan_rtl_loongarch64.S + +diff --git a/libsanitizer/asan/asan_interceptors.h b/libsanitizer/asan/asan_interceptors.h +index 105c672cc..c5534d7f6 100644 +--- a/libsanitizer/asan/asan_interceptors.h ++++ b/libsanitizer/asan/asan_interceptors.h +@@ -119,7 +119,7 @@ void InitializePlatformInterceptors(); + + #if SANITIZER_LINUX && \ + (defined(__arm__) || defined(__aarch64__) || defined(__i386__) || \ +- defined(__x86_64__) || SANITIZER_RISCV64) ++ defined(__x86_64__) || SANITIZER_RISCV64 || SANITIZER_LOONGARCH64) + # define ASAN_INTERCEPT_VFORK 1 + #else + # define ASAN_INTERCEPT_VFORK 0 +diff --git a/libsanitizer/asan/asan_interceptors_vfork.S b/libsanitizer/asan/asan_interceptors_vfork.S +index 3ae5503e8..ec29adc7b 100644 +--- a/libsanitizer/asan/asan_interceptors_vfork.S ++++ b/libsanitizer/asan/asan_interceptors_vfork.S +@@ -6,6 +6,7 @@ + #include "sanitizer_common/sanitizer_common_interceptors_vfork_aarch64.inc.S" + #include "sanitizer_common/sanitizer_common_interceptors_vfork_arm.inc.S" + #include "sanitizer_common/sanitizer_common_interceptors_vfork_i386.inc.S" ++#include "sanitizer_common/sanitizer_common_interceptors_vfork_loongarch64.inc.S" + #include "sanitizer_common/sanitizer_common_interceptors_vfork_riscv64.inc.S" + #include "sanitizer_common/sanitizer_common_interceptors_vfork_x86_64.inc.S" + #endif +diff --git a/libsanitizer/asan/asan_mapping.h b/libsanitizer/asan/asan_mapping.h +index 4b0037fce..6d89a9352 100644 +--- a/libsanitizer/asan/asan_mapping.h ++++ b/libsanitizer/asan/asan_mapping.h +@@ -173,6 +173,7 @@ static const u64 kFreeBSD_ShadowOffset64 = 1ULL << 46; // 0x400000000000 + static const u64 kNetBSD_ShadowOffset32 = 1ULL << 30; // 0x40000000 + static const u64 kNetBSD_ShadowOffset64 = 1ULL << 46; // 0x400000000000 + static const u64 kWindowsShadowOffset32 = 3ULL << 28; // 0x30000000 ++static const u64 kLoongArch64_ShadowOffset64 = 0x0000400000000000; + + #define SHADOW_SCALE kDefaultShadowScale + +@@ -217,6 +218,8 @@ static const u64 kWindowsShadowOffset32 = 3ULL << 28; // 0x30000000 + # define SHADOW_OFFSET kMIPS64_ShadowOffset64 + #elif defined(__sparc__) + #define SHADOW_OFFSET kSPARC64_ShadowOffset64 ++#elif defined(__loongarch__) ++# define SHADOW_OFFSET kLoongArch64_ShadowOffset64 + # elif SANITIZER_WINDOWS64 + # define SHADOW_OFFSET __asan_shadow_memory_dynamic_address + # else +diff --git a/libsanitizer/configure.tgt b/libsanitizer/configure.tgt +index fb89df493..9d42662d3 100644 +--- a/libsanitizer/configure.tgt ++++ b/libsanitizer/configure.tgt +@@ -72,6 +72,13 @@ case "${target}" in + ;; + riscv64-*-linux*) + ;; ++ loongarch64-*-linux*) ++ if test x$ac_cv_sizeof_void_p = x8; then ++ TSAN_SUPPORTED=yes ++ LSAN_SUPPORTED=yes ++ TSAN_TARGET_DEPENDENT_OBJECTS=tsan_rtl_loongarch64.lo ++ fi ++ ;; + *) + UNSUPPORTED=1 + ;; +diff --git a/libsanitizer/lsan/lsan_allocator.h b/libsanitizer/lsan/lsan_allocator.h +index 45c6ac406..dc9a02b19 100644 +--- a/libsanitizer/lsan/lsan_allocator.h ++++ b/libsanitizer/lsan/lsan_allocator.h +@@ -50,7 +50,8 @@ struct ChunkMetadata { + }; + + #if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \ +- defined(__arm__) || SANITIZER_RISCV64 || defined(__hexagon__) ++ defined(__arm__) || SANITIZER_RISCV64 || defined(__hexagon__) || \ ++ defined(__loongarch__) + template <typename AddressSpaceViewTy> + struct AP32 { + static const uptr kSpaceBeg = 0; +diff --git a/libsanitizer/lsan/lsan_common.cpp b/libsanitizer/lsan/lsan_common.cpp +index 308dbb3e4..9a78ed92c 100644 +--- a/libsanitizer/lsan/lsan_common.cpp ++++ b/libsanitizer/lsan/lsan_common.cpp +@@ -167,6 +167,10 @@ static inline bool CanBeAHeapPointer(uptr p) { + unsigned runtimeVMA = + (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1); + return ((p >> runtimeVMA) == 0); ++#elif defined(__loongarch_lp64) ++ // Allow 47-bit user-space VMA at current. ++ return ((p >> 47) == 0); ++ + #else + return true; + #endif +diff --git a/libsanitizer/sanitizer_common/sanitizer_common.h b/libsanitizer/sanitizer_common/sanitizer_common.h +index 065154496..5f68e4994 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_common.h ++++ b/libsanitizer/sanitizer_common/sanitizer_common.h +@@ -696,6 +696,7 @@ enum ModuleArch { + kModuleArchARMV7S, + kModuleArchARMV7K, + kModuleArchARM64, ++ kModuleArchLoongArch64, + kModuleArchRISCV64, + kModuleArchHexagon + }; +@@ -765,6 +766,8 @@ inline const char *ModuleArchToString(ModuleArch arch) { + return "armv7k"; + case kModuleArchARM64: + return "arm64"; ++ case kModuleArchLoongArch64: ++ return "loongarch64"; + case kModuleArchRISCV64: + return "riscv64"; + case kModuleArchHexagon: +diff --git a/libsanitizer/sanitizer_common/sanitizer_common_interceptors_vfork_loongarch64.inc.S b/libsanitizer/sanitizer_common/sanitizer_common_interceptors_vfork_loongarch64.inc.S +new file mode 100644 +index 000000000..dae72b5ac +--- /dev/null ++++ b/libsanitizer/sanitizer_common/sanitizer_common_interceptors_vfork_loongarch64.inc.S +@@ -0,0 +1,57 @@ ++#if defined(__loongarch64) && defined(__linux__) ++ ++#include "sanitizer_common/sanitizer_asm.h" ++ ++ASM_HIDDEN(COMMON_INTERCEPTOR_SPILL_AREA) ++ASM_HIDDEN(_ZN14__interception10real_vforkE) ++ ++.text ++.globl ASM_WRAPPER_NAME(vfork) ++ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork)) ++ASM_WRAPPER_NAME(vfork): ++ // Save ra in the off-stack spill area. ++ // allocate space on stack ++ addi.d $sp, $sp, -16 ++ // store $ra value ++ st.d $ra, $sp, 8 ++ bl COMMON_INTERCEPTOR_SPILL_AREA ++ // restore previous values from stack ++ ld.d $ra, $sp, 8 ++ // adjust stack ++ addi.d $sp, $sp, 16 ++ // store $ra by $a0 ++ st.d $ra, $a0, 0 ++ ++ // Call real vfork. This may return twice. User code that runs between the first and the second return ++ // may clobber the stack frame of the interceptor; that's why it does not have a frame. ++ la.local $a0, _ZN14__interception10real_vforkE ++ ld.d $a0, $a0, 0 ++ jirl $ra, $a0, 0 ++ ++ // adjust stack ++ addi.d $sp, $sp, -16 ++ // store $a0 by adjusted stack ++ st.d $a0, $sp, 8 ++ // jump to exit label if $a0 is 0 ++ beqz $a0, .L_exit ++ ++ // $a0 != 0 => parent process. Clear stack shadow. ++ // put old $sp to $a0 ++ addi.d $a0, $sp, 16 ++ bl %plt(COMMON_INTERCEPTOR_HANDLE_VFORK) ++ ++.L_exit: ++ // Restore $ra ++ bl COMMON_INTERCEPTOR_SPILL_AREA ++ ld.d $ra, $a0, 0 ++ // load value by stack ++ ld.d $a0, $sp, 8 ++ // adjust stack ++ addi.d $sp, $sp, 16 ++ jr $ra ++ASM_SIZE(vfork) ++ ++.weak vfork ++.set vfork, ASM_WRAPPER_NAME(vfork) ++ ++#endif +diff --git a/libsanitizer/sanitizer_common/sanitizer_common_syscalls.inc b/libsanitizer/sanitizer_common/sanitizer_common_syscalls.inc +index a38b13408..954c2ea8c 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_common_syscalls.inc ++++ b/libsanitizer/sanitizer_common/sanitizer_common_syscalls.inc +@@ -2512,7 +2512,7 @@ PRE_SYSCALL(ptrace)(long request, long pid, long addr, long data) { + # if !SANITIZER_ANDROID && \ + (defined(__i386) || defined(__x86_64) || defined(__mips64) || \ + defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__) || \ +- SANITIZER_RISCV64) ++ SANITIZER_RISCV64 || defined(__loongarch__)) + if (data) { + if (request == ptrace_setregs) { + PRE_READ((void *)data, struct_user_regs_struct_sz); +@@ -2534,7 +2534,7 @@ POST_SYSCALL(ptrace)(long res, long request, long pid, long addr, long data) { + # if !SANITIZER_ANDROID && \ + (defined(__i386) || defined(__x86_64) || defined(__mips64) || \ + defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__) || \ +- SANITIZER_RISCV64) ++ SANITIZER_RISCV64 || defined(__loongarch__)) + if (res >= 0 && data) { + // Note that this is different from the interceptor in + // sanitizer_common_interceptors.inc. +diff --git a/libsanitizer/sanitizer_common/sanitizer_linux.cpp b/libsanitizer/sanitizer_common/sanitizer_linux.cpp +index aa59d9718..a3c90bca9 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_linux.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_linux.cpp +@@ -30,6 +30,10 @@ + #include <asm/param.h> + #endif + ++#if SANITIZER_LINUX && defined(__loongarch__) ++# include <sys/sysmacros.h> ++#endif ++ + // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat' + // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To + // access stat from asm/stat.h, without conflicting with definition in +@@ -180,6 +184,8 @@ ScopedBlockSignals::~ScopedBlockSignals() { SetSigProcMask(&saved_, nullptr); } + # include "sanitizer_syscall_linux_arm.inc" + # elif SANITIZER_LINUX && defined(__hexagon__) + # include "sanitizer_syscall_linux_hexagon.inc" ++# elif SANITIZER_LINUX && SANITIZER_LOONGARCH64 ++# include "sanitizer_syscall_linux_loongarch64.inc" + # else + # include "sanitizer_syscall_generic.inc" + # endif +@@ -282,6 +288,28 @@ static void stat64_to_stat(struct stat64 *in, struct stat *out) { + } + #endif + ++#if SANITIZER_LINUX && defined(__loongarch__) ++static void statx_to_stat(struct statx *in, struct stat *out) { ++ internal_memset(out, 0, sizeof(*out)); ++ out->st_dev = makedev(in->stx_dev_major, in->stx_dev_minor); ++ out->st_ino = in->stx_ino; ++ out->st_mode = in->stx_mode; ++ out->st_nlink = in->stx_nlink; ++ out->st_uid = in->stx_uid; ++ out->st_gid = in->stx_gid; ++ out->st_rdev = makedev(in->stx_rdev_major, in->stx_rdev_minor); ++ out->st_size = in->stx_size; ++ out->st_blksize = in->stx_blksize; ++ out->st_blocks = in->stx_blocks; ++ out->st_atime = in->stx_atime.tv_sec; ++ out->st_atim.tv_nsec = in->stx_atime.tv_nsec; ++ out->st_mtime = in->stx_mtime.tv_sec; ++ out->st_mtim.tv_nsec = in->stx_mtime.tv_nsec; ++ out->st_ctime = in->stx_ctime.tv_sec; ++ out->st_ctim.tv_nsec = in->stx_ctime.tv_nsec; ++} ++#endif ++ + #if defined(__mips64) + // Undefine compatibility macros from <sys/stat.h> + // so that they would not clash with the kernel_stat +@@ -336,8 +364,16 @@ uptr internal_stat(const char *path, void *buf) { + #if SANITIZER_FREEBSD + return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf, 0); + #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS ++# if SANITIZER_LINUX && defined(__loongarch__) ++ struct statx bufx; ++ int res = internal_syscall(SYSCALL(statx), AT_FDCWD, (uptr)path, ++ AT_NO_AUTOMOUNT, STATX_BASIC_STATS, (uptr)&bufx); ++ statx_to_stat(&bufx, (struct stat *)buf); ++ return res; ++#else + return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf, + 0); ++#endif + #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS + # if defined(__mips64) + // For mips64, stat syscall fills buffer in the format of kernel_stat +@@ -361,8 +397,17 @@ uptr internal_lstat(const char *path, void *buf) { + return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf, + AT_SYMLINK_NOFOLLOW); + #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS ++# if SANITIZER_LINUX && defined(__loongarch__) ++ struct statx bufx; ++ int res = internal_syscall(SYSCALL(statx), AT_FDCWD, (uptr)path, ++ AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT, ++ STATX_BASIC_STATS, (uptr)&bufx); ++ statx_to_stat(&bufx, (struct stat *)buf); ++ return res; ++#else + return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf, + AT_SYMLINK_NOFOLLOW); ++#endif + #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS + # if SANITIZER_MIPS64 + // For mips64, lstat syscall fills buffer in the format of kernel_stat +@@ -389,6 +434,12 @@ uptr internal_fstat(fd_t fd, void *buf) { + int res = internal_syscall(SYSCALL(fstat), fd, &kbuf); + kernel_stat_to_stat(&kbuf, (struct stat *)buf); + return res; ++# elif SANITIZER_LINUX && defined(__loongarch__) ++ struct statx bufx; ++ int res = internal_syscall(SYSCALL(statx), fd, "", AT_EMPTY_PATH, ++ STATX_BASIC_STATS, (uptr)&bufx); ++ statx_to_stat(&bufx, (struct stat *)buf); ++ return res; + # else + return internal_syscall(SYSCALL(fstat), fd, (uptr)buf); + # endif +@@ -437,7 +488,7 @@ uptr internal_unlink(const char *path) { + } + + uptr internal_rename(const char *oldpath, const char *newpath) { +-#if defined(__riscv) && defined(__linux__) ++#if (defined(__riscv) || defined(__loongarch__)) && defined(__linux__) + return internal_syscall(SYSCALL(renameat2), AT_FDCWD, (uptr)oldpath, AT_FDCWD, + (uptr)newpath, 0); + #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS +@@ -482,7 +533,7 @@ bool FileExists(const char *filename) { + if (ShouldMockFailureToOpen(filename)) + return false; + struct stat st; +-#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS ++#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS && !defined(__loongarch__) + if (internal_syscall(SYSCALL(newfstatat), AT_FDCWD, filename, &st, 0)) + #else + if (internal_stat(filename, &st)) +@@ -1032,7 +1083,7 @@ uptr GetMaxVirtualAddress() { + #if SANITIZER_NETBSD && defined(__x86_64__) + return 0x7f7ffffff000ULL; // (0x00007f8000000000 - PAGE_SIZE) + #elif SANITIZER_WORDSIZE == 64 +-# if defined(__powerpc64__) || defined(__aarch64__) ++# if defined(__powerpc64__) || defined(__aarch64__) || defined(__loongarch__) + // On PowerPC64 we have two different address space layouts: 44- and 46-bit. + // We somehow need to figure out which one we are using now and choose + // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL. +@@ -1040,6 +1091,7 @@ uptr GetMaxVirtualAddress() { + // of the address space, so simply checking the stack address is not enough. + // This should (does) work for both PowerPC64 Endian modes. + // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit. ++ // loongarch64 also has multiple address space layouts: default is 47-bit. + return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1; + #elif SANITIZER_RISCV64 + return (1ULL << 38) - 1; +@@ -1260,6 +1312,47 @@ uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, + : "memory", "r11", "rcx"); + return res; + } ++#elif SANITIZER_LOONGARCH64 ++uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, ++ int *parent_tidptr, void *newtls, int *child_tidptr) { ++ if (!fn || !child_stack) ++ return -EINVAL; ++ ++ CHECK_EQ(0, (uptr)child_stack % 16); ++ ++ register int res __asm__("$a0"); ++ register int __flags __asm__("$a0") = flags; ++ register void *__stack __asm__("$a1") = child_stack; ++ register int *__ptid __asm__("$a2") = parent_tidptr; ++ register int *__ctid __asm__("$a3") = child_tidptr; ++ register void *__tls __asm__("$a4") = newtls; ++ register int (*__fn)(void *) __asm__("$a5") = fn; ++ register void *__arg __asm__("$a6") = arg; ++ register int nr_clone __asm__("$a7") = __NR_clone; ++ ++ __asm__ __volatile__( ++ "syscall 0\n" ++ ++ // if ($a0 != 0) ++ // return $a0; ++ "bnez $a0, 1f\n" ++ ++ // In the child, now. Call "fn(arg)". ++ "move $a0, $a6\n" ++ "jirl $ra, $a5, 0\n" ++ ++ // Call _exit($a0). ++ "addi.d $a7, $zero, %9\n" ++ "syscall 0\n" ++ ++ "1:\n" ++ ++ : "=r"(res) ++ : "0"(__flags), "r"(__stack), "r"(__ptid), "r"(__ctid), "r"(__tls), ++ "r"(__fn), "r"(__arg), "r"(nr_clone), "i"(__NR_exit) ++ : "memory", "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8"); ++ return res; ++} + #elif defined(__mips__) + uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, + int *parent_tidptr, void *newtls, int *child_tidptr) { +@@ -1874,6 +1967,13 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const { + u64 esr; + if (!Aarch64GetESR(ucontext, &esr)) return UNKNOWN; + return esr & ESR_ELx_WNR ? WRITE : READ; ++#elif defined(__loongarch__) ++ u32 flags = ucontext->uc_mcontext.__flags; ++ if (flags & SC_ADDRERR_RD) ++ return SignalContext::READ; ++ if (flags & SC_ADDRERR_WR) ++ return SignalContext::WRITE; ++ return SignalContext::UNKNOWN; + #elif defined(__sparc__) + // Decode the instruction to determine the access type. + // From OpenSolaris $SRC/uts/sun4/os/trap.c (get_accesstype). +@@ -2128,6 +2228,11 @@ static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) { + *pc = ucontext->uc_mcontext.pc; + *bp = ucontext->uc_mcontext.r30; + *sp = ucontext->uc_mcontext.r29; ++# elif defined(__loongarch__) ++ ucontext_t *ucontext = (ucontext_t *)context; ++ *pc = ucontext->uc_mcontext.__pc; ++ *bp = ucontext->uc_mcontext.__gregs22; ++ *sp = ucontext->uc_mcontext.__gregs3; + # else + # error "Unsupported arch" + # endif +diff --git a/libsanitizer/sanitizer_common/sanitizer_linux.h b/libsanitizer/sanitizer_common/sanitizer_linux.h +index 6a235db0e..a6bc01482 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_linux.h ++++ b/libsanitizer/sanitizer_common/sanitizer_linux.h +@@ -73,7 +73,7 @@ int internal_sigaction_norestorer(int signum, const void *act, void *oldact); + void internal_sigdelset(__sanitizer_sigset_t *set, int signum); + #if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) || \ + defined(__powerpc64__) || defined(__s390__) || defined(__i386__) || \ +- defined(__arm__) || SANITIZER_RISCV64 ++ defined(__arm__) || SANITIZER_RISCV64 || defined(__loongarch__) + uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, + int *parent_tidptr, void *newtls, int *child_tidptr); + #endif +diff --git a/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp b/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp +index 4f22c78a1..0fc1d2d44 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp +@@ -203,7 +203,8 @@ void InitTlsSize() { + g_use_dlpi_tls_data = + GetLibcVersion(&major, &minor, &patch) && major == 2 && minor >= 25; + +-#if defined(__aarch64__) || defined(__x86_64__) || defined(__powerpc64__) ++#if defined(__aarch64__) || defined(__x86_64__) || defined(__powerpc64__) || \ ++ defined(__loongarch__) + void *get_tls_static_info = dlsym(RTLD_NEXT, "_dl_get_tls_static_info"); + size_t tls_align; + ((void (*)(size_t *, size_t *))get_tls_static_info)(&g_tls_size, &tls_align); +@@ -262,6 +263,8 @@ static uptr ThreadDescriptorSizeFallback() { + #elif defined(__mips__) + // TODO(sagarthakur): add more values as per different glibc versions. + val = FIRST_32_SECOND_64(1152, 1776); ++#elif SANITIZER_LOONGARCH64 ++ val = 1856; // from glibc 2.36 + #elif SANITIZER_RISCV64 + int major; + int minor; +@@ -301,7 +304,8 @@ uptr ThreadDescriptorSize() { + return val; + } + +-#if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64 ++#if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64 || \ ++ SANITIZER_LOONGARCH64 + // TlsPreTcbSize includes size of struct pthread_descr and size of tcb + // head structure. It lies before the static tls blocks. + static uptr TlsPreTcbSize() { +@@ -311,6 +315,8 @@ static uptr TlsPreTcbSize() { + const uptr kTcbHead = 88; // sizeof (tcbhead_t) + #elif SANITIZER_RISCV64 + const uptr kTcbHead = 16; // sizeof (tcbhead_t) ++#elif SANITIZER_LOONGARCH64 ++ const uptr kTcbHead = 16; // sizeof (tcbhead_t) + #endif + const uptr kTlsAlign = 16; + const uptr kTlsPreTcbSize = +@@ -475,6 +481,15 @@ static void GetTls(uptr *addr, uptr *size) { + *addr = reinterpret_cast<uptr>(__builtin_thread_pointer()) - + ThreadDescriptorSize(); + *size = g_tls_size + ThreadDescriptorSize(); ++#elif SANITIZER_GLIBC && defined(__loongarch__) ++# ifdef __clang__ ++ *addr = reinterpret_cast<uptr>(__builtin_thread_pointer()) - ++ ThreadDescriptorSize(); ++# else ++ asm("or %0,$tp,$zero" : "=r"(*addr)); ++ *addr -= ThreadDescriptorSize(); ++# endif ++ *size = g_tls_size + ThreadDescriptorSize(); + #elif SANITIZER_GLIBC && defined(__powerpc64__) + // Workaround for glibc<2.25(?). 2.27 is known to not need this. + uptr tp; +diff --git a/libsanitizer/sanitizer_common/sanitizer_platform.h b/libsanitizer/sanitizer_common/sanitizer_platform.h +index 3153de34e..ed2d47ddf 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_platform.h ++++ b/libsanitizer/sanitizer_common/sanitizer_platform.h +@@ -225,6 +225,12 @@ + #define SANITIZER_RISCV64 0 + #endif + ++#if defined(__loongarch_lp64) ++# define SANITIZER_LOONGARCH64 1 ++#else ++# define SANITIZER_LOONGARCH64 0 ++#endif ++ + // By default we allow to use SizeClassAllocator64 on 64-bit platform. + // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64 + // does not work well and we need to fallback to SizeClassAllocator32. +@@ -281,8 +287,8 @@ + // mandated by the upstream linux community for all new ports. Other ports + // may still use legacy syscalls. + #ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS +-# if (defined(__aarch64__) || defined(__riscv) || defined(__hexagon__)) && \ +- SANITIZER_LINUX ++# if (defined(__aarch64__) || defined(__riscv) || defined(__hexagon__) || \ ++ defined(__loongarch__)) && SANITIZER_LINUX + # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1 + # else + # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0 +diff --git a/libsanitizer/sanitizer_common/sanitizer_platform_limits_linux.cpp b/libsanitizer/sanitizer_common/sanitizer_platform_limits_linux.cpp +index 2b1a2f793..5962df751 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_platform_limits_linux.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_platform_limits_linux.cpp +@@ -68,7 +68,8 @@ namespace __sanitizer { + + # if !defined(__powerpc64__) && !defined(__x86_64__) && \ + !defined(__aarch64__) && !defined(__mips__) && !defined(__s390__) && \ +- !defined(__sparc__) && !defined(__riscv) && !defined(__hexagon__) ++ !defined(__sparc__) && !defined(__riscv) && !defined(__hexagon__) && \ ++ !defined(__loongarch__) + COMPILER_CHECK(struct___old_kernel_stat_sz == sizeof(struct __old_kernel_stat)); + #endif + +diff --git a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp +index c335f33dd..f5d775839 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp +@@ -94,7 +94,7 @@ + # include <utime.h> + # include <sys/ptrace.h> + # if defined(__mips64) || defined(__aarch64__) || defined(__arm__) || \ +- defined(__hexagon__) || SANITIZER_RISCV64 ++ defined(__hexagon__) || SANITIZER_RISCV64 || defined(__loongarch__) + # include <asm/ptrace.h> + # ifdef __arm__ + typedef struct user_fpregs elf_fpregset_t; +@@ -248,6 +248,10 @@ namespace __sanitizer { + defined(__powerpc__) || defined(__s390__) || defined(__sparc__) || \ + defined(__hexagon__) + # define SIZEOF_STRUCT_USTAT 20 ++# elif defined(__loongarch__) ++ // Not used. The minimum Glibc version available for LoongArch is 2.36 ++ // so ustat() wrapper is already gone. ++# define SIZEOF_STRUCT_USTAT 0 + # else + # error Unknown size of struct ustat + # endif +@@ -322,7 +326,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + #if SANITIZER_LINUX && !SANITIZER_ANDROID && \ + (defined(__i386) || defined(__x86_64) || defined(__mips64) || \ + defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \ +- defined(__s390__) || SANITIZER_RISCV64) ++ defined(__s390__) || SANITIZER_RISCV64) || defined(__loongarch__) + #if defined(__mips64) || defined(__powerpc64__) || defined(__arm__) + unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs); + unsigned struct_user_fpregs_struct_sz = sizeof(elf_fpregset_t); +@@ -332,6 +336,9 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + #elif defined(__aarch64__) + unsigned struct_user_regs_struct_sz = sizeof(struct user_pt_regs); + unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpsimd_state); ++#elif defined(__loongarch__) ++ unsigned struct_user_regs_struct_sz = sizeof(struct user_pt_regs); ++ unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fp_state); + #elif defined(__s390__) + unsigned struct_user_regs_struct_sz = sizeof(struct _user_regs_struct); + unsigned struct_user_fpregs_struct_sz = sizeof(struct _user_fpregs_struct); +@@ -341,7 +348,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + #endif // __mips64 || __powerpc64__ || __aarch64__ + #if defined(__x86_64) || defined(__mips64) || defined(__powerpc64__) || \ + defined(__aarch64__) || defined(__arm__) || defined(__s390__) || \ +- SANITIZER_RISCV64 ++ SANITIZER_RISCV64 || defined(__loongarch__) + unsigned struct_user_fpxregs_struct_sz = 0; + #else + unsigned struct_user_fpxregs_struct_sz = sizeof(struct user_fpxregs_struct); +diff --git a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h +index da53b5abe..f50827d9a 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h ++++ b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h +@@ -99,6 +99,9 @@ const unsigned struct_kernel_stat64_sz = 144; + const unsigned struct___old_kernel_stat_sz = 0; + const unsigned struct_kernel_stat_sz = 64; + const unsigned struct_kernel_stat64_sz = 104; ++# elif defined(__loongarch__) ++const unsigned struct_kernel_stat_sz = 128; ++const unsigned struct_kernel_stat64_sz = 0; + #elif SANITIZER_RISCV64 + const unsigned struct_kernel_stat_sz = 128; + const unsigned struct_kernel_stat64_sz = 0; // RISCV64 does not use stat64 +@@ -125,7 +128,7 @@ const unsigned struct_kexec_segment_sz = 4 * sizeof(unsigned long); + + #if SANITIZER_LINUX + +-#if defined(__powerpc64__) || defined(__s390__) ++#if defined(__powerpc64__) || defined(__s390__) || defined(__loongarch__) + const unsigned struct___old_kernel_stat_sz = 0; + #elif !defined(__sparc__) + const unsigned struct___old_kernel_stat_sz = 32; +@@ -820,7 +823,7 @@ typedef void __sanitizer_FILE; + #if SANITIZER_LINUX && !SANITIZER_ANDROID && \ + (defined(__i386) || defined(__x86_64) || defined(__mips64) || \ + defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \ +- defined(__s390__) || SANITIZER_RISCV64) ++ defined(__s390__) || SANITIZER_RISCV64) || defined(__loongarch__) + extern unsigned struct_user_regs_struct_sz; + extern unsigned struct_user_fpregs_struct_sz; + extern unsigned struct_user_fpxregs_struct_sz; +diff --git a/libsanitizer/sanitizer_common/sanitizer_stacktrace.cpp b/libsanitizer/sanitizer_common/sanitizer_stacktrace.cpp +index 5a12422fc..42182d88e 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_stacktrace.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_stacktrace.cpp +@@ -127,7 +127,7 @@ void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top, + #endif + #elif defined(__s390__) + uhwptr pc1 = frame14; +-#elif defined(__riscv) ++#elif defined(__riscv) || defined(__loongarch__) + // frame-1 contains the return address + uhwptr pc1 = frame-1; + #else +@@ -142,7 +142,7 @@ void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top, + trace_buffersize++ = (uptr) pc1; + } + bottom = (uptr)frame; +-#if defined(__riscv) ++#if defined(__riscv) || defined(__loongarch__) + // frame-2 contain fp of the previous frame + uptr new_bp = (uptr)frame-2; + #else +diff --git a/libsanitizer/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp b/libsanitizer/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp +index 403bda117..d6918f69f 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp +@@ -16,7 +16,7 @@ + #if SANITIZER_LINUX && \ + (defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) || \ + defined(__powerpc64__) || defined(__s390__) || defined(__i386__) || \ +- defined(__arm__) || SANITIZER_RISCV64) ++ defined(__arm__) || SANITIZER_RISCV64 || SANITIZER_LOONGARCH64) + + #include "sanitizer_stoptheworld.h" + +@@ -31,7 +31,8 @@ + #include <sys/types.h> // for pid_t + #include <sys/uio.h> // for iovec + #include <elf.h> // for NT_PRSTATUS +-#if (defined(__aarch64__) || SANITIZER_RISCV64) && !SANITIZER_ANDROID ++#if (defined(__aarch64__) || SANITIZER_RISCV64 || SANITIZER_LOONGARCH64) && \ ++ !SANITIZER_ANDROID + // GLIBC 2.20+ sys/user does not include asm/ptrace.h + # include <asm/ptrace.h> + #endif +@@ -522,6 +523,12 @@ typedef struct user_regs_struct regs_struct; + static constexpr uptr kExtraRegs = {0}; + #define ARCH_IOVEC_FOR_GETREGSET + ++#elif defined(__loongarch__) ++typedef struct user_pt_regs regs_struct; ++#define REG_SP regs3 ++static constexpr uptr kExtraRegs = {0}; ++#define ARCH_IOVEC_FOR_GETREGSET ++ + #elif defined(__s390__) + typedef _user_regs_struct regs_struct; + #define REG_SP gprs15 +diff --git a/libsanitizer/sanitizer_common/sanitizer_symbolizer_libcdep.cpp b/libsanitizer/sanitizer_common/sanitizer_symbolizer_libcdep.cpp +index 3fc994fd3..1b6c0d5c0 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_symbolizer_libcdep.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_symbolizer_libcdep.cpp +@@ -261,6 +261,8 @@ class LLVMSymbolizerProcess final : public SymbolizerProcess { + const char* const kSymbolizerArch = "--default-arch=i386"; + #elif SANITIZER_RISCV64 + const char *const kSymbolizerArch = "--default-arch=riscv64"; ++#elif SANITIZER_LOONGARCH64 ++ const char *const kSymbolizerArch = "--default-arch=loongarch64"; + #elif defined(__aarch64__) + const char* const kSymbolizerArch = "--default-arch=arm64"; + #elif defined(__arm__) +diff --git a/libsanitizer/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc b/libsanitizer/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc +new file mode 100644 +index 000000000..80f5e6be8 +--- /dev/null ++++ b/libsanitizer/sanitizer_common/sanitizer_syscall_linux_loongarch64.inc +@@ -0,0 +1,171 @@ ++//===-- sanitizer_syscall_linux_loongarch64.inc -----------------*- C++ -*-===// ++// ++// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. ++// See https://llvm.org/LICENSE.txt for license information. ++// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception ++// ++//===----------------------------------------------------------------------===// ++// ++// Implementations of internal_syscall and internal_iserror for ++// Linux/loongarch64. ++// ++//===----------------------------------------------------------------------===// ++ ++// About local register variables: ++// https://gcc.gnu.org/onlinedocs/gcc/Local-Register-Variables.html#Local-Register-Variables ++// ++// Kernel ABI: ++// https://lore.kernel.org/loongarch/1f353678-3398-e30b-1c87-6edb278f74db@xen0n.name/T/#m1613bc86c2d7bf5f6da92bd62984302bfd699a2f ++// syscall number is placed in a7 ++// parameters, if present, are placed in a0-a6 ++// upon return: ++// the return value is placed in a0 ++// t0-t8 should be considered clobbered ++// all other registers are preserved ++#define SYSCALL(name) __NR_##name ++ ++#define INTERNAL_SYSCALL_CLOBBERS \ ++ "memory", "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8" ++ ++static uptr __internal_syscall(u64 nr) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0"); ++ __asm__ volatile("syscall 0\n\t" ++ : "=r"(a0) ++ : "r"(a7) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall0(n) (__internal_syscall)(n) ++ ++static uptr __internal_syscall(u64 nr, u64 arg1) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0") = arg1; ++ __asm__ volatile("syscall 0\n\t" ++ : "+r"(a0) ++ : "r"(a7) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall1(n, a1) (__internal_syscall)(n, (u64)(a1)) ++ ++static uptr __internal_syscall(u64 nr, u64 arg1, long arg2) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0") = arg1; ++ register u64 a1 asm("$a1") = arg2; ++ __asm__ volatile("syscall 0\n\t" ++ : "+r"(a0) ++ : "r"(a7), "r"(a1) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall2(n, a1, a2) \ ++ (__internal_syscall)(n, (u64)(a1), (long)(a2)) ++ ++static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0") = arg1; ++ register u64 a1 asm("$a1") = arg2; ++ register u64 a2 asm("$a2") = arg3; ++ __asm__ volatile("syscall 0\n\t" ++ : "+r"(a0) ++ : "r"(a7), "r"(a1), "r"(a2) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall3(n, a1, a2, a3) \ ++ (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3)) ++ ++static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, ++ u64 arg4) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0") = arg1; ++ register u64 a1 asm("$a1") = arg2; ++ register u64 a2 asm("$a2") = arg3; ++ register u64 a3 asm("$a3") = arg4; ++ __asm__ volatile("syscall 0\n\t" ++ : "+r"(a0) ++ : "r"(a7), "r"(a1), "r"(a2), "r"(a3) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall4(n, a1, a2, a3, a4) \ ++ (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4)) ++ ++static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4, ++ long arg5) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0") = arg1; ++ register u64 a1 asm("$a1") = arg2; ++ register u64 a2 asm("$a2") = arg3; ++ register u64 a3 asm("$a3") = arg4; ++ register u64 a4 asm("$a4") = arg5; ++ __asm__ volatile("syscall 0\n\t" ++ : "+r"(a0) ++ : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall5(n, a1, a2, a3, a4, a5) \ ++ (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \ ++ (u64)(a5)) ++ ++static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4, ++ long arg5, long arg6) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0") = arg1; ++ register u64 a1 asm("$a1") = arg2; ++ register u64 a2 asm("$a2") = arg3; ++ register u64 a3 asm("$a3") = arg4; ++ register u64 a4 asm("$a4") = arg5; ++ register u64 a5 asm("$a5") = arg6; ++ __asm__ volatile("syscall 0\n\t" ++ : "+r"(a0) ++ : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall6(n, a1, a2, a3, a4, a5, a6) \ ++ (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \ ++ (u64)(a5), (long)(a6)) ++ ++static uptr __internal_syscall(u64 nr, u64 arg1, long arg2, long arg3, u64 arg4, ++ long arg5, long arg6, long arg7) { ++ register u64 a7 asm("$a7") = nr; ++ register u64 a0 asm("$a0") = arg1; ++ register u64 a1 asm("$a1") = arg2; ++ register u64 a2 asm("$a2") = arg3; ++ register u64 a3 asm("$a3") = arg4; ++ register u64 a4 asm("$a4") = arg5; ++ register u64 a5 asm("$a5") = arg6; ++ register u64 a6 asm("$a6") = arg7; ++ __asm__ volatile("syscall 0\n\t" ++ : "+r"(a0) ++ : "r"(a7), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5), ++ "r"(a6) ++ : INTERNAL_SYSCALL_CLOBBERS); ++ return a0; ++} ++#define __internal_syscall7(n, a1, a2, a3, a4, a5, a6, a7) \ ++ (__internal_syscall)(n, (u64)(a1), (long)(a2), (long)(a3), (long)(a4), \ ++ (u64)(a5), (long)(a6), (long)(a7)) ++ ++#define __SYSCALL_NARGS_X(a1, a2, a3, a4, a5, a6, a7, a8, n, ...) n ++#define __SYSCALL_NARGS(...) \ ++ __SYSCALL_NARGS_X(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0, ) ++#define __SYSCALL_CONCAT_X(a, b) a##b ++#define __SYSCALL_CONCAT(a, b) __SYSCALL_CONCAT_X(a, b) ++#define __SYSCALL_DISP(b, ...) \ ++ __SYSCALL_CONCAT(b, __SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__) ++ ++#define internal_syscall(...) __SYSCALL_DISP(__internal_syscall, __VA_ARGS__) ++ ++// Helper function used to avoid clobbering of errno. ++bool internal_iserror(uptr retval, int *internal_errno) { ++ if (retval >= (uptr)-4095) { ++ if (internal_errno) ++ *internal_errno = -retval; ++ return true; ++ } ++ return false; ++} +diff --git a/libsanitizer/sanitizer_common_interceptors_vfork_loongarch64.inc.S b/libsanitizer/sanitizer_common_interceptors_vfork_loongarch64.inc.S +new file mode 100644 +index 000000000..dae72b5ac +--- /dev/null ++++ b/libsanitizer/sanitizer_common_interceptors_vfork_loongarch64.inc.S +@@ -0,0 +1,57 @@ ++#if defined(__loongarch64) && defined(__linux__) ++ ++#include "sanitizer_common/sanitizer_asm.h" ++ ++ASM_HIDDEN(COMMON_INTERCEPTOR_SPILL_AREA) ++ASM_HIDDEN(_ZN14__interception10real_vforkE) ++ ++.text ++.globl ASM_WRAPPER_NAME(vfork) ++ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork)) ++ASM_WRAPPER_NAME(vfork): ++ // Save ra in the off-stack spill area. ++ // allocate space on stack ++ addi.d $sp, $sp, -16 ++ // store $ra value ++ st.d $ra, $sp, 8 ++ bl COMMON_INTERCEPTOR_SPILL_AREA ++ // restore previous values from stack ++ ld.d $ra, $sp, 8 ++ // adjust stack ++ addi.d $sp, $sp, 16 ++ // store $ra by $a0 ++ st.d $ra, $a0, 0 ++ ++ // Call real vfork. This may return twice. User code that runs between the first and the second return ++ // may clobber the stack frame of the interceptor; that's why it does not have a frame. ++ la.local $a0, _ZN14__interception10real_vforkE ++ ld.d $a0, $a0, 0 ++ jirl $ra, $a0, 0 ++ ++ // adjust stack ++ addi.d $sp, $sp, -16 ++ // store $a0 by adjusted stack ++ st.d $a0, $sp, 8 ++ // jump to exit label if $a0 is 0 ++ beqz $a0, .L_exit ++ ++ // $a0 != 0 => parent process. Clear stack shadow. ++ // put old $sp to $a0 ++ addi.d $a0, $sp, 16 ++ bl %plt(COMMON_INTERCEPTOR_HANDLE_VFORK) ++ ++.L_exit: ++ // Restore $ra ++ bl COMMON_INTERCEPTOR_SPILL_AREA ++ ld.d $ra, $a0, 0 ++ // load value by stack ++ ld.d $a0, $sp, 8 ++ // adjust stack ++ addi.d $sp, $sp, 16 ++ jr $ra ++ASM_SIZE(vfork) ++ ++.weak vfork ++.set vfork, ASM_WRAPPER_NAME(vfork) ++ ++#endif +diff --git a/libsanitizer/tsan/Makefile.am b/libsanitizer/tsan/Makefile.am +index ae588a67d..709cdcdea 100644 +--- a/libsanitizer/tsan/Makefile.am ++++ b/libsanitizer/tsan/Makefile.am +@@ -50,7 +50,7 @@ tsan_files = \ + tsan_vector_clock.cpp + + libtsan_la_SOURCES = $(tsan_files) +-EXTRA_libtsan_la_SOURCES = tsan_rtl_amd64.S tsan_rtl_aarch64.S tsan_rtl_mips64.S tsan_rtl_ppc64.S tsan_rtl_s390x.S ++EXTRA_libtsan_la_SOURCES = tsan_rtl_amd64.S tsan_rtl_aarch64.S tsan_rtl_mips64.S tsan_rtl_ppc64.S tsan_rtl_s390x.S tsan_rtl_loongarch64.S + libtsan_la_LIBADD = $(top_builddir)/sanitizer_common/libsanitizer_common.la $(top_builddir)/interception/libinterception.la $(TSAN_TARGET_DEPENDENT_OBJECTS) + libtsan_la_DEPENDENCIES = $(top_builddir)/sanitizer_common/libsanitizer_common.la $(top_builddir)/interception/libinterception.la $(TSAN_TARGET_DEPENDENT_OBJECTS) + if LIBBACKTRACE_SUPPORTED +diff --git a/libsanitizer/tsan/Makefile.in b/libsanitizer/tsan/Makefile.in +index 538d2e8eb..194ed946d 100644 +--- a/libsanitizer/tsan/Makefile.in ++++ b/libsanitizer/tsan/Makefile.in +@@ -456,7 +456,7 @@ tsan_files = \ + tsan_vector_clock.cpp + + libtsan_la_SOURCES = $(tsan_files) +-EXTRA_libtsan_la_SOURCES = tsan_rtl_amd64.S tsan_rtl_aarch64.S tsan_rtl_mips64.S tsan_rtl_ppc64.S tsan_rtl_s390x.S ++EXTRA_libtsan_la_SOURCES = tsan_rtl_amd64.S tsan_rtl_aarch64.S tsan_rtl_mips64.S tsan_rtl_ppc64.S tsan_rtl_s390x.S tsan_rtl_loongarch64.S + libtsan_la_LIBADD = \ + $(top_builddir)/sanitizer_common/libsanitizer_common.la \ + $(top_builddir)/interception/libinterception.la \ +@@ -609,6 +609,7 @@ distclean-compile: + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tsan_report.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tsan_rtl.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tsan_rtl_aarch64.Plo@am__quote@ ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tsan_rtl_loongarch64.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tsan_rtl_access.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tsan_rtl_amd64.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tsan_rtl_mips64.Plo@am__quote@ +diff --git a/libsanitizer/tsan/tsan_interceptors_posix.cpp b/libsanitizer/tsan/tsan_interceptors_posix.cpp +index 9a85ee00d..ada8fd031 100644 +--- a/libsanitizer/tsan/tsan_interceptors_posix.cpp ++++ b/libsanitizer/tsan/tsan_interceptors_posix.cpp +@@ -76,6 +76,8 @@ struct ucontext_t { + #define PTHREAD_ABI_BASE "GLIBC_2.3.2" + #elif defined(__aarch64__) || SANITIZER_PPC64V2 + #define PTHREAD_ABI_BASE "GLIBC_2.17" ++#elif SANITIZER_LOONGARCH64 ++#define PTHREAD_ABI_BASE "GLIBC_2.36" + #endif + + extern "C" int pthread_attr_init(void *attr); +diff --git a/libsanitizer/tsan/tsan_platform.h b/libsanitizer/tsan/tsan_platform.h +index 7ff0acace..0ec562dac 100644 +--- a/libsanitizer/tsan/tsan_platform.h ++++ b/libsanitizer/tsan/tsan_platform.h +@@ -85,6 +85,58 @@ struct Mapping48AddressSpace { + static const uptr kVdsoBeg = 0xf000000000000000ull; + }; + ++/* C/C++ on linux/loongarch64 (47-bit VMA) ++0000 0000 4000 - 0080 0000 0000: main binary ++0080 0000 0000 - 0100 0000 0000: - ++0100 0000 0000 - 1000 0000 0000: shadow memory ++1000 0000 0000 - 3000 0000 0000: - ++3000 0000 0000 - 3400 0000 0000: metainfo ++3400 0000 0000 - 5555 0000 0000: - ++5555 0000 0000 - 5556 0000 0000: main binary (PIE) ++5556 0000 0000 - 7ffe 0000 0000: - ++7ffe 0000 0000 - 7fff 0000 0000: heap ++7fff 0000 0000 - 7fff 8000 0000: - ++7fff 8000 0000 - 8000 0000 0000: modules and main thread stack ++*/ ++// struct MappingLoongArch64_47 { ++// static const uptr kMetaShadowBeg = 0x300000000000ull; ++// static const uptr kMetaShadowEnd = 0x340000000000ull; ++// static const uptr kShadowBeg = 0x010000000000ull; ++// static const uptr kShadowEnd = 0x100000000000ull; ++// static const uptr kHeapMemBeg = 0x7ffe00000000ull; ++// static const uptr kHeapMemEnd = 0x7fff00000000ull; ++// static const uptr kLoAppMemBeg = 0x000000004000ull; ++// static const uptr kLoAppMemEnd = 0x008000000000ull; ++// static const uptr kMidAppMemBeg = 0x555500000000ull; ++// static const uptr kMidAppMemEnd = 0x555600000000ull; ++// static const uptr kHiAppMemBeg = 0x7fff80000000ull; ++// static const uptr kHiAppMemEnd = 0x800000000000ull; ++// static const uptr kShadowMsk = 0x780000000000ull; ++// static const uptr kShadowXor = 0x040000000000ull; ++// static const uptr kShadowAdd = 0x000000000000ull; ++// static const uptr kVdsoBeg = 0x7fffffffc000ull; ++// }; ++struct MappingLoongArch64_47 { ++ static const uptr kMetaShadowBeg = 0x300000000000ull; ++ static const uptr kMetaShadowEnd = 0x340000000000ull; ++ static const uptr kShadowBeg = 0x010000000000ull; ++ static const uptr kShadowEnd = 0x100000000000ull; ++ static const uptr kHeapMemBeg = 0x7ffe00000000ull; ++ static const uptr kHeapMemEnd = 0x7fff00000000ull; ++ static const uptr kLoAppMemBeg = 0x000000004000ull; ++ static const uptr kLoAppMemEnd = 0x008000000000ull; ++ static const uptr kMidAppMemBeg = 0x555500000000ull; ++ static const uptr kMidAppMemEnd = 0x555600000000ull; ++ static const uptr kHiAppMemBeg = 0x7fff80000000ull; ++ static const uptr kHiAppMemEnd = 0x800000000000ull; ++ static const uptr kTraceMemBeg = 0x600000000000ull; ++ static const uptr kTraceMemEnd = 0x620000000000ull; ++ static const uptr kShadowMsk = 0x780000000000ull; ++ static const uptr kShadowXor = 0x040000000000ull; ++ static const uptr kShadowAdd = 0x000000000000ull; ++ static const uptr kVdsoBeg = 0x7fffffffc000ull; ++}; ++ + /* + C/C++ on linux/mips64 (40-bit VMA) + 0000 0000 00 - 0100 0000 00: - (4 GB) +@@ -674,6 +726,8 @@ ALWAYS_INLINE auto SelectMapping(Arg arg) { + return Func::template Apply<MappingMips64_40>(arg); + # elif defined(__s390x__) + return Func::template Apply<MappingS390x>(arg); ++# elif SANITIZER_LOONGARCH64 ++ return Func::template Apply<MappingLoongArch64_47>(arg); + # else + # error "unsupported platform" + # endif +@@ -684,6 +738,7 @@ ALWAYS_INLINE auto SelectMapping(Arg arg) { + template <typename Func> + void ForEachMapping() { + Func::template Apply<Mapping48AddressSpace>(); ++ Func::template Apply<MappingLoongArch64_47>(); + Func::template Apply<MappingMips64_40>(); + Func::template Apply<MappingAppleAarch64>(); + Func::template Apply<MappingAarch64_39>(); +diff --git a/libsanitizer/tsan/tsan_platform_linux.cpp b/libsanitizer/tsan/tsan_platform_linux.cpp +index 73ec14892..995634b9c 100644 +--- a/libsanitizer/tsan/tsan_platform_linux.cpp ++++ b/libsanitizer/tsan/tsan_platform_linux.cpp +@@ -66,7 +66,8 @@ extern "C" void *__libc_stack_end; + void *__libc_stack_end = 0; + #endif + +-#if SANITIZER_LINUX && defined(__aarch64__) && !SANITIZER_GO ++#if SANITIZER_LINUX && (defined(__aarch64__) || defined(__loongarch_lp64)) && \ ++ !SANITIZER_GO + # define INIT_LONGJMP_XOR_KEY 1 + #else + # define INIT_LONGJMP_XOR_KEY 0 +@@ -242,6 +243,14 @@ void InitializePlatformEarly() { + Die(); + } + #endif ++#elif SANITIZER_LOONGARCH64 ++# if !SANITIZER_GO ++ if (vmaSize != 47) { ++ Printf("FATAL: ThreadSanitizer: unsupported VMA range\n"); ++ Printf("FATAL: Found %zd - Supported 47\n", vmaSize); ++ Die(); ++ } ++# endif + #elif defined(__powerpc64__) + # if !SANITIZER_GO + if (vmaSize != 44 && vmaSize != 46 && vmaSize != 47) { +@@ -302,7 +311,7 @@ void InitializePlatform() { + SetAddressSpaceUnlimited(); + reexec = true; + } +-#if SANITIZER_LINUX && defined(__aarch64__) ++#if SANITIZER_LINUX && (defined(__aarch64__) || defined(__loongarch_lp64)) + // After patch "arm64: mm: support ARCH_MMAP_RND_BITS." is introduced in + // linux kernel, the random gap between stack and mapped area is increased + // from 128M to 36G on 39-bit aarch64. As it is almost impossible to cover +@@ -387,6 +396,8 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) { + # else + return mangled_sp; + # endif ++#elif defined(__loongarch_lp64) ++ return mangled_sp ^ longjmp_xor_key; + #elif defined(__powerpc64__) + // Reverse of: + // ld r4, -28696(r13) +@@ -418,6 +429,8 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) { + #elif SANITIZER_LINUX + # ifdef __aarch64__ + # define LONG_JMP_SP_ENV_SLOT 13 ++# elif defined(__loongarch__) ++# define LONG_JMP_SP_ENV_SLOT 1 + # elif defined(__mips64) + # define LONG_JMP_SP_ENV_SLOT 1 + # elif defined(__s390x__) +@@ -444,7 +457,11 @@ static void InitializeLongjmpXorKey() { + + // 2. Retrieve vanilla/mangled SP. + uptr sp; ++#ifdef __loongarch__ ++ asm("move %0, $sp" : "=r" (sp)); ++#else + asm("mov %0, sp" : "=r" (sp)); ++#endif + uptr mangled_sp = ((uptr *)&env)LONG_JMP_SP_ENV_SLOT; + + // 3. xor SPs to obtain key. +diff --git a/libsanitizer/tsan/tsan_rtl.h b/libsanitizer/tsan/tsan_rtl.h +index eab837042..6a7e255ad 100644 +--- a/libsanitizer/tsan/tsan_rtl.h ++++ b/libsanitizer/tsan/tsan_rtl.h +@@ -55,7 +55,8 @@ namespace __tsan { + + #if !SANITIZER_GO + struct MapUnmapCallback; +-#if defined(__mips64) || defined(__aarch64__) || defined(__powerpc__) ++#if defined(__mips64) || defined(__aarch64__) || defined(__powerpc__) || \ ++ defined(__loongarch__) + + struct AP32 { + static const uptr kSpaceBeg = 0; +diff --git a/libsanitizer/tsan/tsan_rtl_loongarch64.S b/libsanitizer/tsan/tsan_rtl_loongarch64.S +new file mode 100644 +index 000000000..12856bd11 +--- /dev/null ++++ b/libsanitizer/tsan/tsan_rtl_loongarch64.S +@@ -0,0 +1,196 @@ ++#include "sanitizer_common/sanitizer_asm.h" ++ ++.section .text ++ ++ASM_HIDDEN(__tsan_setjmp) ++.comm _ZN14__interception11real_setjmpE,8,8 ++.globl ASM_SYMBOL_INTERCEPTOR(setjmp) ++ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(setjmp)) ++ASM_SYMBOL_INTERCEPTOR(setjmp): ++ CFI_STARTPROC ++ ++ // Save frame pointer and return address register ++ addi.d $sp, $sp, -32 ++ st.d $ra, $sp, 24 ++ st.d $fp, $sp, 16 ++ CFI_DEF_CFA_OFFSET (32) ++ CFI_OFFSET (1, -8) ++ CFI_OFFSET (22, -16) ++ ++ // Adjust the SP for previous frame ++ addi.d $fp, $sp, 32 ++ CFI_DEF_CFA_REGISTER (22) ++ ++ // Save env parameter ++ st.d $a0, $sp, 8 ++ CFI_OFFSET (4, -24) ++ ++ // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)` ++ addi.d $a0, $fp, 0 ++ ++ // call tsan interceptor ++ bl ASM_SYMBOL(__tsan_setjmp) ++ ++ // Restore env parameter ++ ld.d $a0, $sp, 8 ++ CFI_RESTORE (4) ++ ++ // Restore frame/link register ++ ld.d $fp, $sp, 16 ++ ld.d $ra, $sp, 24 ++ addi.d $sp, $sp, 32 ++ CFI_RESTORE (22) ++ CFI_RESTORE (1) ++ CFI_DEF_CFA (3, 0) ++ ++ // tail jump to libc setjmp ++ la.local $a1, _ZN14__interception11real_setjmpE ++ ld.d $a1, $a1, 0 ++ jr $a1 ++ ++ CFI_ENDPROC ++ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(setjmp)) ++ ++.comm _ZN14__interception12real__setjmpE,8,8 ++.globl ASM_SYMBOL_INTERCEPTOR(_setjmp) ++ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(_setjmp)) ++ASM_SYMBOL_INTERCEPTOR(_setjmp): ++ CFI_STARTPROC ++ ++ // Save frame pointer and return address register ++ addi.d $sp, $sp, -32 ++ st.d $ra, $sp, 24 ++ st.d $fp, $sp, 16 ++ CFI_DEF_CFA_OFFSET (32) ++ CFI_OFFSET (1, -8) ++ CFI_OFFSET (22, -16) ++ ++ // Adjust the SP for previous frame ++ addi.d $fp, $sp, 32 ++ CFI_DEF_CFA_REGISTER (22) ++ ++ // Save env parameter ++ st.d $a0, $sp, 8 ++ CFI_OFFSET (4, -24) ++ ++ // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)` ++ addi.d $a0, $fp, 0 ++ ++ // call tsan interceptor ++ bl ASM_SYMBOL(__tsan_setjmp) ++ ++ // Restore env parameter ++ ld.d $a0, $sp, 8 ++ CFI_RESTORE (4) ++ ++ // Restore frame/link register ++ ld.d $fp, $sp, 16 ++ ld.d $ra, $sp, 24 ++ addi.d $sp, $sp, 32 ++ CFI_RESTORE (22) ++ CFI_RESTORE (1) ++ CFI_DEF_CFA (3, 0) ++ ++ // tail jump to libc setjmp ++ la.local $a1, _ZN14__interception12real__setjmpE ++ ld.d $a1, $a1, 0 ++ jr $a1 ++ ++ CFI_ENDPROC ++ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(_setjmp)) ++ ++.comm _ZN14__interception14real_sigsetjmpE,8,8 ++.globl ASM_SYMBOL_INTERCEPTOR(sigsetjmp) ++ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(sigsetjmp)) ++ASM_SYMBOL_INTERCEPTOR(sigsetjmp): ++ CFI_STARTPROC ++ ++ // Save frame pointer and return address register ++ addi.d $sp, $sp, -32 ++ st.d $ra, $sp, 24 ++ st.d $fp, $sp, 16 ++ CFI_DEF_CFA_OFFSET (32) ++ CFI_OFFSET (1, -8) ++ CFI_OFFSET (22, -16) ++ ++ // Adjust the SP for previous frame ++ addi.d $fp, $sp, 32 ++ CFI_DEF_CFA_REGISTER (22) ++ ++ // Save env parameter ++ st.d $a0, $sp, 8 ++ CFI_OFFSET (4, -24) ++ ++ // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)` ++ addi.d $a0, $fp, 0 ++ ++ // call tsan interceptor ++ bl ASM_SYMBOL(__tsan_setjmp) ++ ++ // Restore env parameter ++ ld.d $a0, $sp, 8 ++ CFI_RESTORE (4) ++ ++ // Restore frame/link register ++ ld.d $fp, $sp, 16 ++ ld.d $ra, $sp, 24 ++ addi.d $sp, $sp, 32 ++ CFI_RESTORE (22) ++ CFI_RESTORE (1) ++ CFI_DEF_CFA (3, 0) ++ ++ // tail jump to libc setjmp ++ la.local $a1, _ZN14__interception14real_sigsetjmpE ++ ld.d $a1, $a1, 0 ++ jr $a1 ++ ++ CFI_ENDPROC ++ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(sigsetjmp)) ++ ++.comm _ZN14__interception16real___sigsetjmpE,8,8 ++.globl ASM_SYMBOL_INTERCEPTOR(__sigsetjmp) ++ASM_TYPE_FUNCTION(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp)) ++ASM_SYMBOL_INTERCEPTOR(__sigsetjmp): ++ CFI_STARTPROC ++ ++ // Save frame pointer and return address register ++ addi.d $sp, $sp, -32 ++ st.d $ra, $sp, 24 ++ st.d $fp, $sp, 16 ++ CFI_DEF_CFA_OFFSET (32) ++ CFI_OFFSET (1, -8) ++ CFI_OFFSET (22, -16) ++ ++ // Adjust the SP for previous frame ++ addi.d $fp, $sp, 32 ++ CFI_DEF_CFA_REGISTER (22) ++ ++ // Save env parameter ++ st.d $a0, $sp, 8 ++ CFI_OFFSET (4, -24) ++ ++ // Obtain SP, first argument to `void __tsan_setjmp(uptr sp)` ++ addi.d $a0, $fp, 0 ++ ++ // call tsan interceptor ++ bl ASM_SYMBOL(__tsan_setjmp) ++ ++ // Restore env parameter ++ ld.d $a0, $sp, 8 ++ CFI_RESTORE (4) ++ ++ // Restore frame/link register ++ ld.d $fp, $sp, 16 ++ ld.d $ra, $sp, 24 ++ addi.d $sp, $sp, 32 ++ CFI_RESTORE (22) ++ CFI_RESTORE (1) ++ CFI_DEF_CFA (3, 0) ++ ++ // tail jump to libc setjmp ++ la.local $a1, _ZN14__interception16real___sigsetjmpE ++ ld.d $a1, $a1, 0 ++ jr $a1 ++ ++ CFI_ENDPROC ++ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp)) +-- +2.33.0 +
View file
_service:tar_scm:loongarch-add-alternatives-for-idiv-insns-to-improve.patch
Added
@@ -0,0 +1,184 @@ +From 03a6da5290c60437a0fc97347bb84c120c26cc58 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 6 Jul 2022 13:45:55 +0800 +Subject: PATCH 001/124 loongarch: add alternatives for idiv insns to improve + code generation + +Currently in the description of LoongArch integer division instructions, +the output is marked as earlyclobbered ('&'). It's necessary when +loongarch_check_zero_div_p() because clobbering operand 2 (divisor) will +make the checking for zero divisor impossible. + +But, for -mno-check-zero-division (the default of GCC >= 12.2 for +optimized code), the output is not earlyclobbered at all. And, the +read of operand 1 only occurs before clobbering the output. So we make +three alternatives for an idiv instruction: + +* (=r,r,r): For -mno-check-zero-division. +* (=&r,r,r): For -mcheck-zero-division. +* (=&r,0,r): For -mcheck-zero-division, to explicitly allow patterns + like "div.d $a0, $a0, $a1". + +gcc/ChangeLog: + + * config/loongarch/loongarch.cc (loongarch_check_zero_div_p): + Remove static, for use in the machine description file. + * config/loongarch/loongarch-protos.h: + (loongarch_check_zero_div_p): Add prototype. + * config/loongarch/loongarch.md (enabled): New attr. + (*<optab><mode>3): Add (=r,r,r) and (=&r,0,r) alternatives for + idiv. Conditionally enable the alternatives using + loongarch_check_zero_div_p. + (<optab>di3_fake): Likewise. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/div-1.c: New test. + * gcc.target/loongarch/div-2.c: New test. + * gcc.target/loongarch/div-3.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch-protos.h | 1 + + gcc/config/loongarch/loongarch.cc | 2 +- + gcc/config/loongarch/loongarch.md | 28 +++++++++++++++------- + gcc/testsuite/gcc.target/loongarch/div-1.c | 9 +++++++ + gcc/testsuite/gcc.target/loongarch/div-2.c | 9 +++++++ + gcc/testsuite/gcc.target/loongarch/div-3.c | 9 +++++++ + 6 files changed, 49 insertions(+), 9 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/div-1.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/div-2.c + create mode 100644 gcc/testsuite/gcc.target/loongarch/div-3.c + +diff --git a/gcc/config/loongarch/loongarch-protos.h b/gcc/config/loongarch/loongarch-protos.h +index 2144c2421..2287fd376 100644 +--- a/gcc/config/loongarch/loongarch-protos.h ++++ b/gcc/config/loongarch/loongarch-protos.h +@@ -130,6 +130,7 @@ extern bool loongarch_symbol_binds_local_p (const_rtx); + extern const char *current_section_name (void); + extern unsigned int current_section_flags (void); + extern bool loongarch_use_ins_ext_p (rtx, HOST_WIDE_INT, HOST_WIDE_INT); ++extern bool loongarch_check_zero_div_p (void); + + union loongarch_gen_fn_ptrs + { +diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc +index 22901cb61..750d53bbe 100644 +--- a/gcc/config/loongarch/loongarch.cc ++++ b/gcc/config/loongarch/loongarch.cc +@@ -2110,7 +2110,7 @@ loongarch_load_store_insns (rtx mem, rtx_insn *insn) + + /* Return true if we need to trap on division by zero. */ + +-static bool ++bool + loongarch_check_zero_div_p (void) + { + /* if -mno-check-zero-division is given explicitly. */ +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 8f8412fba..6bca2ed39 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -110,6 +110,8 @@ + ;; + ;; .................... + ++(define_attr "enabled" "no,yes" (const_string "yes")) ++ + (define_attr "got" "unset,load" + (const_string "unset")) + +@@ -763,26 +765,36 @@ + }) + + (define_insn "*<optab><mode>3" +- (set (match_operand:GPR 0 "register_operand" "=&r") +- (any_div:GPR (match_operand:GPR 1 "register_operand" "r") +- (match_operand:GPR 2 "register_operand" "r"))) ++ (set (match_operand:GPR 0 "register_operand" "=r,&r,&r") ++ (any_div:GPR (match_operand:GPR 1 "register_operand" "r,r,0") ++ (match_operand:GPR 2 "register_operand" "r,r,r"))) + "" + { + return loongarch_output_division ("<insn>.<d><u>\t%0,%1,%2", operands); + } + (set_attr "type" "idiv") +- (set_attr "mode" "<MODE>")) ++ (set_attr "mode" "<MODE>") ++ (set (attr "enabled") ++ (if_then_else ++ (match_test "!!which_alternative == loongarch_check_zero_div_p()") ++ (const_string "yes") ++ (const_string "no")))) + + (define_insn "<optab>di3_fake" +- (set (match_operand:SI 0 "register_operand" "=&r") +- (any_div:SI (match_operand:DI 1 "register_operand" "r") +- (match_operand:DI 2 "register_operand" "r"))) ++ (set (match_operand:SI 0 "register_operand" "=r,&r,&r") ++ (any_div:SI (match_operand:DI 1 "register_operand" "r,r,0") ++ (match_operand:DI 2 "register_operand" "r,r,r"))) + "" + { + return loongarch_output_division ("<insn>.w<u>\t%0,%1,%2", operands); + } + (set_attr "type" "idiv") +- (set_attr "mode" "SI")) ++ (set_attr "mode" "SI") ++ (set (attr "enabled") ++ (if_then_else ++ (match_test "!!which_alternative == loongarch_check_zero_div_p()") ++ (const_string "yes") ++ (const_string "no")))) + + ;; Floating point multiply accumulate instructions. + +diff --git a/gcc/testsuite/gcc.target/loongarch/div-1.c b/gcc/testsuite/gcc.target/loongarch/div-1.c +new file mode 100644 +index 000000000..b1683f853 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/div-1.c +@@ -0,0 +1,9 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mcheck-zero-division" } */ ++/* { dg-final { scan-assembler "div.\wd\\t\\\$r4,\\\$r4,\\\$r5" } } */ ++ ++long ++div(long a, long b) ++{ ++ return a / b; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/div-2.c b/gcc/testsuite/gcc.target/loongarch/div-2.c +new file mode 100644 +index 000000000..4c2beb5b9 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/div-2.c +@@ -0,0 +1,9 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mno-check-zero-division" } */ ++/* { dg-final { scan-assembler "div.\wd\\t\\\$r4,\\\$r5,\\\$r4" } } */ ++ ++long ++div(long a, long b) ++{ ++ return b / a; ++} +diff --git a/gcc/testsuite/gcc.target/loongarch/div-3.c b/gcc/testsuite/gcc.target/loongarch/div-3.c +new file mode 100644 +index 000000000..d25969263 +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/div-3.c +@@ -0,0 +1,9 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mcheck-zero-division" } */ ++/* { dg-final { scan-assembler-not "div.\wd\\t\\\$r4,\\\$r5,\\\$r4" } } */ ++ ++long ++div(long a, long b) ++{ ++ return b / a; ++} +-- +2.33.0 +
View file
_service:tar_scm:loongarch-avoid-unnecessary-sign-extend-after-32-bit.patch
Added
@@ -0,0 +1,102 @@ +From f69237e2e7d129e680fc0bd6a79c53aa193f2ef0 Mon Sep 17 00:00:00 2001 +From: Xi Ruoyao <xry111@xry111.site> +Date: Wed, 6 Jul 2022 23:22:29 +0800 +Subject: PATCH 002/124 loongarch: avoid unnecessary sign-extend after 32-bit + division + +Like add.w/sub.w/mul.w, div.w/mod.w/div.wu/mod.wu also sign-extend the +output on LA64. But, LoongArch v1.00 mandates that the inputs of 32-bit +division to be sign-extended so we have to expand 32-bit division into +RTL sequences. + +We defined div.w/mod.w/div.wu/mod.wu as a (DI, DI) -> SI instruction. +This definition does not indicate the fact that these instructions will +store the result as sign-extended value in a 64-bit GR. Then the +compiler would emit unnecessary sign-extend operations. For example: + + int div(int a, int b) { return a / b; } + +was compiled to: + + div.w $r4, $r4, $r5 + slli.w $r4, $r4, 0 # this is unnecessary + jr $r1 + +To remove this unnecessary operation, we change the division +instructions to (DI, DI) -> DI and describe the sign-extend behavior +explicitly in the RTL template. In the expander for 32-bit division we +then use simplify_gen_subreg to extract the lower 32 bits. + +gcc/ChangeLog: + + * config/loongarch/loongarch.md (<any_div>di3_fake): Describe + the sign-extend of result in the RTL template. + (<any_div><mode>3): Adjust for <any_div>di3_fake change. + +gcc/testsuite/ChangeLog: + + * gcc.target/loongarch/div-4.c: New test. + +Signed-off-by: Peng Fan <fanpeng@loongson.cn> +Signed-off-by: ticat_fp <fanpeng@loongson.cn> +--- + gcc/config/loongarch/loongarch.md | 12 ++++++++---- + gcc/testsuite/gcc.target/loongarch/div-4.c | 9 +++++++++ + 2 files changed, 17 insertions(+), 4 deletions(-) + create mode 100644 gcc/testsuite/gcc.target/loongarch/div-4.c + +diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md +index 6bca2ed39..5c0445dd8 100644 +--- a/gcc/config/loongarch/loongarch.md ++++ b/gcc/config/loongarch/loongarch.md +@@ -752,6 +752,7 @@ + { + rtx reg1 = gen_reg_rtx (DImode); + rtx reg2 = gen_reg_rtx (DImode); ++ rtx rd = gen_reg_rtx (DImode); + + operands1 = gen_rtx_SIGN_EXTEND (word_mode, operands1); + operands2 = gen_rtx_SIGN_EXTEND (word_mode, operands2); +@@ -759,7 +760,9 @@ + emit_insn (gen_rtx_SET (reg1, operands1)); + emit_insn (gen_rtx_SET (reg2, operands2)); + +- emit_insn (gen_<optab>di3_fake (operands0, reg1, reg2)); ++ emit_insn (gen_<optab>di3_fake (rd, reg1, reg2)); ++ emit_insn (gen_rtx_SET (operands0, ++ simplify_gen_subreg (SImode, rd, DImode, 0))); + DONE; + } + }) +@@ -781,9 +784,10 @@ + (const_string "no")))) + + (define_insn "<optab>di3_fake" +- (set (match_operand:SI 0 "register_operand" "=r,&r,&r") +- (any_div:SI (match_operand:DI 1 "register_operand" "r,r,0") +- (match_operand:DI 2 "register_operand" "r,r,r"))) ++ (set (match_operand:DI 0 "register_operand" "=r,&r,&r") ++ (sign_extend:DI ++ (any_div:SI (match_operand:DI 1 "register_operand" "r,r,0") ++ (match_operand:DI 2 "register_operand" "r,r,r")))) + "" + { + return loongarch_output_division ("<insn>.w<u>\t%0,%1,%2", operands); +diff --git a/gcc/testsuite/gcc.target/loongarch/div-4.c b/gcc/testsuite/gcc.target/loongarch/div-4.c +new file mode 100644 +index 000000000..a52f87d6c +--- /dev/null ++++ b/gcc/testsuite/gcc.target/loongarch/div-4.c +@@ -0,0 +1,9 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2" } */ ++/* { dg-final { scan-assembler-not "slli" } } */ ++ ++int ++div(int a, int b) ++{ ++ return a / b; ++} +-- +2.33.0 +
Locations
Projects
Search
Status Monitor
Help
Open Build Service
OBS Manuals
API Documentation
OBS Portal
Reporting a Bug
Contact
Mailing List
Forums
Chat (IRC)
Twitter
Open Build Service (OBS)
is an
openSUSE project
.
浙ICP备2022010568号-2